Thread and String literal pool

[Abimaran Kugathasan]

I got this question from Exam Lab Test 01.

class XSync	implements Runnable	{
	public void run()	{
		synchronized("x")	{ // synchronized on String object "x".
			System.out.println("X ");
			this.run2();
		}
	}
	public void run2()	{
		synchronized("x")	{ // This also synchronized on "x".
			System.out.println("X2 ");
		}
	}
}

public class MCe	{
	public static void main(String[] args)	{
		XSync ns = new XSync();
		Thread t1 = new Thread(ns);
		Thread t2 = new Thread(ns);
		t1.start();
		t2.start();
	}
}

The output :

X
X2
X
X2

Don't those methods be synchronized on the String Literal pool object x? Thanks in Advanced!

[Ankit Garg]

Yes the synchronized blocks will synchronize on the String "x" from the pool. Do you have some doubts about the output?? Here run2 is called from a synchronized block, so the thread already holds the lock on the desired object when run2 is called...

[Prasad Kharkar]

line 3 is causes the method to be synchronized on the object "x"
this means that no other thread can access the synchronized code till the lock is acquired
now in that method
we call the run2() method
and this method is also synchronized on the object "x"
now when t1 or t2 is started
only one of the thread will run the synchronized code
and also the method called from the synchronized block is synchronized on the same object "x" (due to the String literal pool)
hence the method run2 can be accessed by the object of which lock the thread has acquired and it can call run2 through run method
hence
the output should contain X and then X2 for any order of the threads that are started and start executing