Life cycle of a Thread (Thread States)

Synchronization

Synchronization is the concept of avoidance of data inconsistency problem due to multiple threads trying to access a common resource. But synchronization causes performance degradation hence it should be only used when there is a need.

The threads of a program may want to access a system resource at a time.  In this case, data inconsistency problem may arise.  To avoid this problem, we have to provide exclusive access (Lock) to any one of the thread interested in the system resource.

Read operation need not synchronization but update, delete operations need synchronization.

For example, x is an object

t1,t2 and t3 are the three threads want to access the object.

can these three read data at a time from x? yes

but t1 wants to update(add, modify) the data in x

while t2 wants to read the data in x

The synchronization can provide exclusive lock at object level.  synchronization can be achieved by using ‘synchronized’ keyword. This ‘synchronized’ modifier is applicable only for methods and blocks but not for classes and variables. 

class x extends Thread

{

            synchronized m1()

            {

            }

            synchronized m2()

            {

            }

            m3()

            {

            }

}

//example code where there is no synchronization is required

class Table1

{

            void printTable(int n)

{

            for(int i=1;i<=10;i++)

            {

                        System.out.print(i+”x”+n+”=”);

                        try

                        {

                                    Thread.sleep(2000);

                        }

                        catch(InterruptedException e)

                        {

                        }

                        System.out.println(i*n);

            }

}

}

class TableThread extends Thread

{

            Table1 tobj=new Table1();

            TableThread(Table1 tobj)

            {

                        this.tobj=tobj;

            }

            public void run()

            {

                        tobj.printTable(5);

            }

}

public class Synchronization {

            public static void main(String[] args) {

                        Table1 tobj=new Table1();

                        TableThread t=new TableThread(tobj);

                        t.start();

            }

}

Output of the above program:

1×5=5

2×5=10

……

10×5=50

Now, try the same program by creating more one thread for accessing the same object of class Table1 and check the output.  You will get irregular output.  The solution for this problem is making the printTable() method as synchronized.

The above example is demonstrating, if multiple threads are accessing same object then only synchronization is required.  But there will be no use of synchronized keyword when the threads are accessing different independent objects that is again we will get irregular output.  The solution for this is static synchronized.          

static synchronized is used to obtain class level lock.

Only synchronized enables to obtain object level lock.

If a thread wants to execute any static synchronized method, then that thread requires class level lock to access the method.

Once thread got class level lock, then it is allowed execute any static synchronized method of that class.

Once method execution completes, automatically thread releases lock.

Synchronized keyword will be used for enclosing critical section of the program.

Two levels of locks:

1. class level
2. object level

while a thread executing static synchronized method, remaining threads are not allowed to execute any static synchronized methods of that class.  But remaining threads are allowed execute, normal static method, synchronized instant method, normal instant method.

Class X

{

Static sync m1();

Static sync m2();

Sync m3();

Static m4();

M5();

}

//Example code where two threads are executing two different methods of same object

class Display

{

            public void showN()

            {

                        for(int i=1;i<=10;i++)

                        {

                                    System.out.print(i);

                        try

                        {

                                    Thread.sleep(2000);

                        }

                        catch(InterruptedException e)

                        {

                        }

                        }

            }

            public void showC()

            {

                        for(int i=65;i<=75;i++)

                        {

                                    System.out.print((char)i);

                        try

                        {

                                    Thread.sleep(2000);

                        }

                        catch(InterruptedException e)

                        {

                        }

                        }

            }

}

class ThreadN extends Thread

{

            Display d;

            ThreadN(Display d)

            {

                        this.d=d;

            }

            public void run()

            {

                        d.showN();

            }

}

class ThreadC extends Thread

{

            Display d;

            ThreadC(Display d)

            {

                        this.d=d;

            }

            public void run()

            {

                        d.showC();

            }

}

public class Synchornization {

            public static void main(String[] args) {

                        Display d=new Display();

                        ThreadN t1=new ThreadN(d);

                        ThreadC t2=new ThreadC(d);

                        t1.start();

                        t2.start();

            }

}

Output: A1B2C3D4E5F67G8H9I10JK

By making both showN() and showC() methods as synchronized we can get the output as:

12345678910ABCDEFGHIJK

//another example code showing how threads compete for one object without synchronization

class PrintDemo {

               public void printCount() {

                                    try {

                     for(int i = 5; i > 0; i–) {

                        System.out.println(“Counter   —   ”  + i );

                     }

                  } catch (Exception e) {

                     System.out.println(“Thread  interrupted.”);

                  }

               }

            }

class ThreadDemo2 extends Thread {

               private Thread t;

               private String threadName;

               PrintDemo  PD;

               ThreadDemo2( String name,  PrintDemo pd) {

                  threadName = name;

                  PD = pd;

               }

               public void run() {

                  PD.printCount();

                  System.out.println(“Thread ” +  threadName + ” exiting.”);

               }

               public void start () {

                  System.out.println(“Starting ” +  threadName );

                  if (t == null) {

                     t = new Thread (this, threadName);

                     t.start ();

                  }

               }

            }

public class SyncTest2 {

            public static void main(String[] args) {

                        PrintDemo PD = new PrintDemo();

                  ThreadDemo2 T1 = new ThreadDemo2( “Thread – 1 “, PD );

                  ThreadDemo2 T2 = new ThreadDemo2( “Thread – 2 “, PD );

                  T1.start();

                  T2.start();

                  // wait for threads to end

                     try {

                     T1.join();

                     T2.join();

                  } catch ( Exception e) {

                     System.out.println(“Interrupted”);

                  }

            }

}

The above code will give irregular output which can be solved by using synchronized keyword.