Insights into synchronization

[Mallik Kumar]

Hi, folks...I have struggled with the concepts of Synchronization for a long time. They are still nebulous...but I could get some insights.

Let us start with two threads invoked on the same object...

public class BothInMethod
{
	String Id;

	public BothInMethod(String Id)
	{
		this.Id=Id;
	}

	public void doStuff(int arg)                  //both threads will be inside doStuff()  at the same time threadA precedes threadB by 200 millis
	{
		print("Entering doStuff");

		int num=arg*2 + Id.length();                          //each thread will have their own copy of local var (num) and their respective (num) values will be different
		print("in doStuff, value of num=" + num);

		try
		{
			Thread.sleep(2000);            //slow down
		}catch(Exception e){}

		print("exiting doStuff()");
	}

	public void print(String msg)
	{
		String name=Thread.currentThread().getName();
		System.out.println(name+ ": ObjId- " + Id + " " + msg);

	}

	public static void main (String[] args) throws InterruptedException
    {
    	final BothInMethod bim =new BothInMethod("Obj1");        //Instantiated with an Identifier Obj1 and name (bim)

		Runnable runA=new Runnable(){
			public void run()
			{
				bim.doStuff(3);
			}
		};
		Thread threadA=new Thread(runA,"ThreadA");
		threadA.start();                      //threadA is  started and invokes doStuff() method on the object (bim)

		Thread.sleep(200);

		Runnable runB=new Runnable(){
			public void run()
			{
				bim.doStuff(7);
			}
		};
		Thread threadB=new Thread(runB,"ThreadB");
		threadB.start();                       //Thread B is started after 200 milliseconds and invokes doStuff on the same object (bim)
    }
}

Your output should match.

ThreadA: ObjId- Obj1 Entering doStuff
ThreadA: ObjId- Obj1 in doStuff, value of num=10
ThreadB: ObjId- Obj1 Entering doStuff
ThreadB: ObjId- Obj1 in doStuff, value of num=18
ThreadA: ObjId- Obj1 exiting doStuff()
ThreadB: ObjId- Obj1 exiting doStuff()


I use the word chaos for a non-deterministic output.

1. Two threads invoked on the same object (bim) and two different Runnables (runA & runB) or the same Runnable target
will result in chaos when they enter a non-synchronized method.
2. In order to synchronize, place a synchronized keyword at line 10 after the 'public' keyword. Your output should match.

ThreadA: ObjId- Obj1 Entering doStuff
ThreadA: ObjId- Obj1 in doStuff, value of num=10
ThreadA: ObjId- Obj1 exiting doStuff()
ThreadB: ObjId- Obj1 Entering doStuff
ThreadB: ObjId- Obj1 in doStuff, value of num=18
ThreadB: ObjId- Obj1 exiting doStuff()




Two Threads invoked on different Objects and two different Runnables will cause chaos.

public class TwoBothInMethod
{
	String Id;

	public TwoBothInMethod(String Id)
	{
		this.Id=Id;
	}

	public synchronized void doStuff(int arg)             //Note: doStuff() is synchronized but there is no competition for exclusive access
	{                                                                 // for the Object level lock because there bim1 and bim2 have their own object level locks.
		print("Entering doStuff");                         // threadA acquires access to the bim1 lock and threadB to bim2

		int num=arg*2+Id.length();
		print("in doStuff, value of num=" + num);

		try
		{
			Thread.sleep(2000);
		}catch(Exception e){}

		print("exiting doStuff()");
	}

	public void print(String msg)
	{
		String name=Thread.currentThread().getName();
		System.out.println(name+ ": ObjId- " + Id + " " + msg);

	}

	public static void main (String[] args) throws InterruptedException
    {
    	final TwoBothInMethod bim1=new TwoBothInMethod("Obj1");     //Two different objects are created.
    	final TwoBothInMethod bim2=new TwoBothInMethod("Obj2");

		Runnable runA=new Runnable(){
			public void run()
			{
				bim1.doStuff(3);
			}
		};
		Thread threadA=new Thread(runA,"ThreadA");        //doStuff method of bim1 is invoked by threadA
		threadA.start();

		Thread.sleep(200);

		Runnable runB=new Runnable(){
			public void run()
			{
				bim2.doStuff(7);
			}
		};
		Thread threadB=new Thread(runB,"ThreadB");      //doStuff method of bim2 is invoked by threadB
		threadB.start();
    }
}

1. Two threads invoked on the different objects (bim1 & bim2) and two different Runnables will produce chaos
even when the method they enter is synchronized because they obtain locks for diferent objects (bim1 & bim2).

ThreadA: ObjId- Obj1 Entering doStuff
ThreadA: ObjId- Obj1 in doStuff, value of num=10
ThreadB: ObjId- Obj2 Entering doStuff
ThreadB: ObjId- Obj2 in doStuff, value of num=18
ThreadA: ObjId- Obj1 exiting doStuff()
ThreadB: ObjId- Obj2 exiting doStuff()

2. But if the Runnable targets are same (Example: use runA for both the threads) they are synchronized, because they have to compete for bim1 lock.

ThreadA: ObjId- Obj1 Entering doStuff
ThreadA: ObjId- Obj1 in doStuff, value of num=10
ThreadA: ObjId- Obj1 exiting doStuff()
ThreadB: ObjId- Obj1 Entering doStuff
ThreadB: ObjId- Obj1 in doStuff, value of num=10
ThreadB: ObjId- Obj1 exiting doStuff()


Simple STATIC synchronization

public class StaticNeedsSync
{
	private static int nextSerialNum=1001;

	public static int getNextSerialNum()           //getNextSerialNum() is static and needs to be synchronized
	{
		int sn=nextSerialNum;

		try
		{
			Thread.sleep(1000);
		}catch(InterruptedException e){}

		nextSerialNum++;
		return sn;
	}

	private static void print(String msg)
	{
		System.out.println(Thread.currentThread().getName()+":"+msg);
	}

	public static void main(String... args)
	{
		Runnable r=new Runnable(){
			public void run()
			{
				print("getNextSerialNum()=" + getNextSerialNum());
			}
		};
		try
		{
			Thread threadA=new Thread(r,"threadA");
			threadA.start();

			Thread.sleep(1500);         //enough time for threadA to enter and return from getNextSerialNum()

			Thread threadB=new Thread(r,"threadB");
			threadB.start();

			Thread.sleep(500);                                                         

			Thread threadC=new Thread(r,"threadC");
			threadC.start();              //both threadB and threadC will be inside getNextSerialNum() at the same time...they both "see" 1002 as their serial num

			Thread.sleep(2500);         //sleep for 2.5 sec, plenty of time for both Thread B & C to complete

			Thread threadD=new Thread(r,"threadD");     //all four threads use the same Runnable 'r'
			threadD.start();
		}catch(InterruptedException e){}
	}
}

Output:
threadA:getNextSerialNum()=1001
threadB:getNextSerialNum()=1002
threadC:getNextSerialNum()=1002
threadD:getNextSerialNum()=1004

On synchronizing getNextSerialNum(), we have the following required output:

threadA:getNextSerialNum()=1001
threadB:getNextSerialNum()=1002
threadC:getNextSerialNum()=1003
threadD:getNextSerialNum()=1004


Static Block synchronization

public class StaticBlock
{
	public synchronized static void  staticA()             //static and synchronized
	{
		String name=Thread.currentThread().getName();
		System.out.println("Entering staticA..." + name);
		System.out.println("In staticA...");
		try
		{
			Thread.sleep(5000);
		}catch(InterruptedException e){} 
		System.out.println("Exiting staticA..." + Thread.currentThread().getName());
	}

	public static void staticB()        //static and has a synchronized block
	{
		String name=Thread.currentThread().getName();
		System.out.println("Entering staticB.." + name);
		synchronized(StaticBlock.class)   //object used to control access to this block is 'Class' object for StaticBlock and is found using StaticBlock.class
		{
			System.out.println("In staticB...inside sync block");
			try
			{
				Thread.sleep(2000);
			}catch(InterruptedException  e) {}
		}
		System.out.println("Exiting staticB..." + Thread.currentThread().getName());
	}

	public static void main(String... a)
	{
		Runnable runA=new Runnable(){
			public void run()
			{
				StaticBlock.staticA();
			}
		};
		Thread threadA=new Thread(runA,"threadA");
		threadA.start();      //threadA invokes staticA()

		try
		{
			Thread.sleep(200);      //After a brief 200 millis threadB is started
		}catch(InterruptedException e){}

		Runnable runB=new Runnable(){
			public void run()
			{
				StaticBlock.staticB();
			}
		};

		Thread threadB=new Thread(runB,"threadB");
		threadB.start();  //invokes staticB()
	}
}

while threadA is sleeping at line 10...threadB enters staticB() and prints a message, and blocks waiting to enter the synchronized statement block.
Only when threadA returns form staticA(), will threadB get access to the class-level lock and complete staticB().

Output:
Entering staticA...threadA
In staticA...inside sync block
Entering staticB..threadB //blocks till threadA completes
Exiting staticA...threadA //threadA exits
In staticB...inside sync block //threadB can now get the class lock and enter the synchronized block
Exiting staticB...threadB

I am still a newbie and am still studying synchronized blocks for objects (non-static). Hope this helps a raw beginner.

[bartek bartekw]

.