C#’ta Monitor Sınıfı İle Thread Kontrolü

Merhaba,

Asenkron yaklaşım sergilediğimiz çalışmalarımızda herhangi bir T anında farklı Thread’lardaki işlemleri belirli bir sıralama gözeterek gerçekleştirmek için Lock yapısından faydalanmaktayız. Lock yapısı, farklı Thread’larda çalışan Processlerin aynı anda işlenmesinden ziyade Lock bloklarının sırasıyla hiyerarşi gözetilerek senkron bir şekilde işlenmesini sağlayan bir yapıdır. İşte bu işlemin aynısını gerçekleştirmemizi sağlayan Monitor sınıfını ve ilgili metotlarını bu içeriğimizde ele alacağız.

Hemen aşağıdaki kod bloğunu ele alalım…

    class Program
    {
        static void Main(string[] args)
        {
            Task t1 = new Task(() =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.Write("* ");
                    Thread.Sleep(100);
                }
            });
            Task t2 = new Task(() =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.Write("- ");
                    Thread.Sleep(100);
                }
            });
            Task t3 = new Task(() =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.Write("+ ");
                    Thread.Sleep(100);
                }
            });
            t1.Start();
            t2.Start();
            t3.Start();

            Console.Read();
        }
    }

Bu programı derleyip çalıştırdığımız zaman asenkron bir çalışma sonucu aşağıdaki ekran görüntüsüne benzer karışık bir vaziyette sonuçlar elde edeceğiz.

C#'ta Monitor Sınıfı İle Thread Kontrolü

Makalemizin başlarında da bahsettiğimiz gibi bu tarz durumlarda senkron bir işleyiş istiyorsak eğer aşağıdaki gibi Lock bloğunu kullanmamız yeterli olacaktır.

    class Program
    {
        static void Main(string[] args)
        {
            object o = new object();

            Task t1 = new Task(() =>
            {
                lock (o)
                {
                    for (int i = 0; i < 5; i++)
                    {
                        Console.Write("* ");
                        Thread.Sleep(100);
                    }
                }
            });
            Task t2 = new Task(() =>
            {
                lock (o)
                {
                    for (int i = 0; i < 5; i++)
                    {
                        Console.Write("- ");
                        Thread.Sleep(100);
                    }
                }
            });
            Task t3 = new Task(() =>
            {
                lock (o)
                {
                    for (int i = 0; i < 5; i++)
                    {
                        Console.Write("+ ");
                        Thread.Sleep(100);
                    }
                }
            });
            t1.Start();
            t2.Start();
            t3.Start();

            Console.Read();
        }
    }

Bu şekilde çalıştığımız zaman aşağıdaki ekran görüntüsüne benzer sonuçlarla karşılaşacağız.
C#'ta Monitor Sınıfı İle Thread Kontrolü
Gördüğünüz gibi asenkron çalışan farklı Thread’lar Lock mekanizması aracılığıyla senkron bir şekilde işlenmektedir.

Şimdi bu işlemin aynısını Monitor sınıfı aracılığıyla gerçekleştirelim.

    class Program
    {
        static void Main(string[] args)
        {
            object o = new object();

            Task t1 = new Task(() =>
            {
                Monitor.Enter(o);
                for (int i = 0; i < 5; i++)
                {
                    Console.Write("* ");
                    Thread.Sleep(100);
                }
                Monitor.Exit(o);
            });
            Task t2 = new Task(() =>
            {
                Monitor.Enter(o);
                for (int i = 0; i < 5; i++)
                {
                    Console.Write("- ");
                    Thread.Sleep(100);
                }
                Monitor.Exit(o);
            });
            Task t3 = new Task(() =>
            {
                Monitor.Enter(o);
                for (int i = 0; i < 5; i++)
                {
                    Console.Write("+ ");
                    Thread.Sleep(100);
                }
                Monitor.Exit(o);
            });
            t1.Start();
            t2.Start();
            t3.Start();

            Console.Read();
        }
    }

C#'ta Monitor Sınıfı İle Thread Kontrolü

Benzer şekilde her bir Thread’ın çalışma takibi diğer bir Thread’a nazaran başlangıç ve bitiş olarak baz alınmakta ve senkron bir vaziyette işlenmektedir. Anlayacağınız Lock mekanizmasının scopelarının yaptığı görevi Monitor sınıfının Enter ve Exit metodları üstlenmektedir.

Sonraki yazılarımda görüşmek üzere…
Şimdilik hoşçakalın…
İyi çalışmalar dilerim…

You may also like...

Bir Cevap Yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

CAPTCHA (Şahıs Denetim Kodu) Resmi

*

Copy Protected by Chetan's WP-Copyprotect.