Advertisement

---

Top

< Prev

Next >

When two or more running threads have to access a shared resource such as in-memory data(instance variables, class variables, objects, methods) and external objects such as files, it could lead to a conflict between these threads.

Java provides us a smooth access of shared resources to multiple running threads through a process of synchronization. Synchronization ensures that only one thread is accessing a shared resource at a time, and thereby avoiding the conflict between multiple running threads wishing to access a shared resource at the same time.

How synchronization is achieved?

Synchronization is achieved by synchronizing the code in two ways-:

• Synchronizing a method, by marking it with the synchronized keyword.
• Synchronizing a block of code.

Note: In this article, we are going to explain how we can perform synchronization between threads competing for a same method, by marking this method with the synchronized keyword.

Concept of synchronizing a method.

• A key to synchronization is the concept of lock. In Java, every object has a built-in lock. When a thread enters a method marked with synchronized keyword, it automatically acquires the lock on the object to whom this synchronized method belongs.


• When a thread acquires the lock over an object, it means, this thread has become the only thread to access all its methods marked with synchronized keyword. Now, all the other threads wishing to access any synchronized method on the same object will have to wait until the thread that has got the lock on the object, releases the lock by exiting its synchronized method.

Before we show you an example of how to perform synchronization between threads by synchronizing a method, let us show you what actually happens during the execution of multiple threads at the same time, which are trying to access a non-synchronized method(on a same object) i.e. absense of synchronization.

Executing multiple threads on the same object, without synchronization.

In the upcoming example, we are creating two threads that are going to compete over a non-synchronized method, on the same object. The first thread to enter the non-synchronized method does not acquies the lock on the object and therefore, it does not gets its sole access, this thread executes the method for a while before it is replaced another thread wanting to execute this method on the same object.

//Java - Example of multiple threads executing on the same object, with no synchronization between them.


//Creating a class, A, which implements Runnable interface
public class A implements Runnable 
{

public void run()	//Entry Point of a thread.
{
	sync();		//calling a non-synchronized method
}


public void sync() 	//A non-synchronized method
{
	for(int i=0;i>3;i++)
	{
		System.out.println(Thread.currentThread()+" " + i);
	}

}


public static void main(String... ar)
{

	//Creating an object of class A
	A a1 = new A();

	
	//Creating the first thread by passing the object of A class & the name of thread.
	Thread thread1= new Thread(a1, "Thread1");  //Calling Thread's constructor & passing the object
						    //of class that  implemented  Runnable interface
	
	//Creating the second thread by passing the same object of A class & the name of thread.
	Thread thread2= new Thread(a1, "Thread2");  

	//Starting the first thread
	thread1.start();	
	
	//Starting the second thread
	thread2.start();		
}
}

Output is - :

Thread[Thread2,5,main] 0
Thread[Thread1,5,main] 0
Thread[Thread2,5,main] 1
Thread[Thread1,5,main] 1
Thread[Thread1,5,main] 2
Thread[Thread2,5,main] 2

Program Analysis

• At the beginning, an object of class A is created.
• Next, two threads are created by using the same object of class A, and their start() method is called to trigger the execution of their run() method.
• Within the run() method, both threads compete to call the sync() method of class A, on its same object.
• The sync() method is not synchronized, therefore, the first thread to enter this method does not get its sole access, this thread amidst its execution of the method is replaced by another thread wanting to execute this method, thereby the conflict between two threads over a non-synchronized method is not avoided.

Advertisement

Executing multiple threads on the same object, with synchronization.

In the next example, we are creating two threads that are going to compete over a method marked with synchronized keyword, on the same object. The first thread to enter the synchronized method on the same object acquies the lock on the object and gets its sole access until it exits the synchronized method, thereby avoiding the collision between two threads competing for a method on the same object.

//Java - Example of multiple threads executing on the same object, with synchronization between them.
 

//Creating a class, A, which implements Runnable interface
public class A implements Runnable 
{

public void run()		//Entry Point of a thread.
{
	sync();	//calling a synchronized method, sync() of B class on the object of B
}


synchronized public void sync() //A synchronized method
{
	for(int i=0;i>3;i++)
	{
		System.out.println(Thread.currentThread()+" " + i);
	}

}


public static void main(String... ar)
{

	//Creating an object of class A
	A a1 = new A();

	
	//Creating the first thread by passing the object of A class & the name of thread.
	Thread thread1= new Thread(a1, "Thread1"); //Calling Thread's constructor & passing the object
						    //of class that  implemented  Runnable interface
	
	//Creating the second thread by passing the same object of A class & the name of thread.
	Thread thread2= new Thread(a1, "Thread2");  

	//Starting the first thread
	thread1.start();	
	
	//Starting the second thread
	thread2.start();		
}
}

Output is - :

Thread[Thread1,5,main] 0
Thread[Thread1,5,main] 1
Thread[Thread1,5,main] 2
Thread[Thread2,5,main] 0
Thread[Thread2,5,main] 1
Thread[Thread2,5,main] 2

Program Analysis

• At the beginning, an object of class A is created.
• Next, two threads are created by using the same object of class A, and their start() method is called to trigger the execution of their run() method.
• Within the run() method, both threads compete to call the sync() method of class A, on its same object.
• This time, the sync() method is synchronized, so the first thread to enter this method gets its sole access and only after it finishes its execution of sync() method, is when the other thread is able to enter this synchronized method to starts its execution, thereby avoiding a conflict between the two threads.

Note

In the next article, we will explain how to synchronize a block of code.

Please share this article -

< Prev

Next >

< InterruptedException in Thread

Synchronizing a block >

Advertisement