Java’da Multithreading ( Thread Safety synchronized intrinsic lock ) – 3

Önceki yazımda (buradan ulaşabilirsiniz) Thread’lerin yaşam döngüsünden bahsettim. Bu yazıda synchronized nedir? Java’da thread işlemlerinde synchronized nasıl yapılır örneklerle anlatacağım.

Programımızdaki işlemlerin thread sırasında iş önceliğinin rastgele olması ve değerlerin sıralı ya da senkronize olarak çalışmaması sorununu “synchronized” anahtar kelimesi ile nasıl çözeceğimizden bahsedeceğim.

Problemi anlamak için bir örnek yapalım ve bu örnekte bir senkron problemi olacaktır. Bir sayacımız olacak ve ilk önce ilk thread’imize 10 sayısını vereceğiz ve 15’e kadar saydıracağız. Sonraki thread’imize 500 vereceğiz ve bu işlemde de 505’e kadar saymasını isteyen kodumuzu yazıyoruz.

class Count
{
    void print(int n) throws InterruptedException {
        for(int i=1;i<=5;i++)
        {
            System.out.println(n++);
            Thread.sleep(500);
        }

    }
}

class MyThread1 extends Thread
{
    Count count;
    MyThread1(Count count)
    {
        this.count = count;
    }
    public void run()
    {
        try {
            count.print(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
class MyThread2 extends Thread
{
    Count c;
    MyThread2(Count c)
    {
        this.c=c;
    }
    public void run()
    {
        try {
            c.print(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main
{
    public static void main(String args[])
    {
        Count obj = new Count();
        MyThread1 t1=new MyThread1(obj);
        MyThread2 t2=new MyThread2(obj);
        t1.start();
        t2.start();
    }
}

Çıktımıza bakalım.

10
500
501
11
12
502
13
503
504
14

Yukarıdaki çıktıdan anlayacağınız üzere arttırma işlemine threadden gelen iş parçacıklarının rastgele geldiğini görebilmekteyiz.

Thread’lerin verdiğimiz sıraya göre çalışmasını yani o threaddeki işlemin bittiğinden emin olduktan sonra diğer thread’deki işlemlerin çalışmasını istersek;

synchronized

synchronized ananhtar kelimesi, senkronize olarak çalışmasını istedğimiz kod bloğunun önüne koyduğumuz zaman çözülür. Yaptığımız örnekte sayacımızı arttıran metodun senkronize olarak çalışmasını istiyoruz ve bir thread’deki iş parçacığı bitmeden diğerinin başlamayacağını garanti eder.

class Count
{
  synchronized   void print(int n) throws InterruptedException {
        for(int i=1;i<=5;i++)
        {
            System.out.println(n++);
            Thread.sleep(500);
        }

    }
}

class MyThread1 extends Thread
{
    Count count;
    MyThread1(Count count)
    {
        this.count = count;
    }
    public void run()
    {
        try {
            count.print(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
class MyThread2 extends Thread
{
    Count c;
    MyThread2(Count c)
    {
        this.c=c;
    }
    public void run()
    {
        try {
            c.print(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main
{
    public static void main(String args[])
    {
        Count obj = new Count();
        MyThread1 t1=new MyThread1(obj);
        MyThread2 t2=new MyThread2(obj);
        t1.start();
        t2.start();
    }
}

Çıktımız

10
11
12
13
14
500
501
502
503
504

Anahtar kelime sayesinde sorunumuz çözüldü.

intrinsic lock ederek yani synchronized ederek bir threadin işi varken diğer thread’leri bekletir.