Synchronization

Threads commonly share the same memory space area, that’s why they can share the resources. Threads commonly communicate by sharing access to fields and the objects reference fields refer to. This communication type is extremely efficient, but makes two kinds of problems: thread interference and memory consistency errors. By the synchronization tool we can avoid this problem. In other words, There is very critical situation where we want only one thread at a time has to access a shared resources. For example, suppose two people each have a checkbook for a single account same as like two different threads are accessing the same account data.
     
Lock
    
This term refers to the access granted to a particular thread that can access the shared resources. At any given time, only one thread can hold the lock and thereby have access to the shared resource. Every object in Java has build-in lock that only comes in action when the object has synchronized method code. By associating a shared resource with a Java object and its lock, the object can act as a guard, ensuring synchronized access to the resource. Only one thread at a time can access the shared resource guarded by the object lock.
    
Since there is one lock per object, if one thread has acquired the lock, no other thread can acquire the lock until the lock is not released by first thread. Acquire the lock means the thread currently in synchronized method and released the lock means exits the synchronized method. Remember the following points related to lock and synchronization:

public class SynThread{
	public static void main(String args[]){
		Share s=new Share();
		MyThread m1=new MyThread(s,"Thread1");
		MyThread m2=new MyThread(s,"Thread2");
		MyThread m3=new MyThread(s,"Thread3");
	}
}
class MyThread extends Thread{
	Share s;
	MyThread(Share s,String str){
		super(str);
		this.s=s;
		start();
	}
	public void run(){
		s.doword(Thread.currentThread().getName());
	}
}
class Share{
	public synchronized void doword(String str){
		for(int i=0;i<5;i++){
		System.out.println("Started   :"+str);
		try{
			Thread.sleep(100);
		}catch(Exception e){}
		}
	}
}

Output of the program is:

Download this example

Synchronized Blocks (Statements)

A synchronized statement is another way to create synchronized code. Synchronized statements must specify the object that provides the intrinsic lock. The synchronized block allows execution of arbitrary code to be synchronized on the lock of an arbitrary object.

General form of synchronized block is:
synchronized (object reference expression)
{
code block..
}

The following program demonstrates the synchronized block:

public class SynStatement{
	public static void main(String args[]){
		Share s=new Share();
		MyThread m1=new MyThread(s,"Thread1");
		MyThread m2=new MyThread(s,"Thread2");
		MyThread m3=new MyThread(s,"Thread3");
	}
}
class MyThread extends Thread{
	Share s;
	MyThread(Share s,String str){
		super(str);
		this.s=s;
		start();
	}
	public void run(){
		s.doword(Thread.currentThread().getName());
	}
}
class Share{
	public void doword(String str){
		synchronized(this){
		for(int i=0;i<5;i++){
		System.out.println("Started   :"+str);
		try{
			Thread.sleep(100);
		}catch(Exception e){}
		}
		}
	}
}

Output of the program is:

Download this example