Thread synchronization

Consider a scenario ,where two different threads having access to a single instance of a class , and both threads invoke methods on that object and those methods modify the state of the object.

For example , consider a ATM transaction scenario. Suppose there a two people say 'A' and 'B' sharing the same account and each have their own card to withdraw money from ATM.Each goes through a process of checking the available balance and then withdrawing the cash.

Consider 'A' as ThreadA and 'B' as ThreadB.

1.ThreadA checks the balance (balance=Rs.500), and then sleeps for some time.
2.In the mean time , ThreadB checks the balance (balance=Rs.500) and withdraws some cash(withdrawal=200).
3.Now ThreadA wakesup and tries to withdraw the cash of Rs.500 and finds "Not enough money available in your account".

This problem is known as a "race condition," where multiple threads can access the same resource (typically an object's instance variables), and can produce corrupted data if one thread "races in" too quickly before an operation that should be "atomic" has completed.

In this case 'balance' is the variable accessed and modified by both threads , through the methods of checking and withdrawing.

In order to avoid this problem , we implement the concept of synchronization by
1.Marking the variable(balance) private
2.Synchronize the code that modifies the variables.

Synchronization guarants that , when ThreadA has entered the operation of checking and withdrawing , no other thread is allowed to acces or modify the variable(balance) even if ThreadA falls asleep. Other Threads can access and modify , only if ThreadA completes the operation and exits the run method.

sample for the above scenario :

public class AccountDanger implements Runnable 

{ 

 private Account acct = new Account();

 public static void main (String [] args) 

 { 

  AccountDanger r = new AccountDanger(); 

  Thread ThreadA = new Thread(r); 

  Thread ThreadB = new Thread(r); 

  ThreadA.setName("ThreadA"); 

  ThreadB.setName("ThreadB");

  ThreadA.start(); 

  ThreadB.start(); 

 } 

 public void run() 

 { 

  for (int x = 0; x <>= amt) 

  { 

   System.out.println(Thread.currentThread().getName()+ " is going to withdraw"); 

   try { Thread.sleep(500); }

   catch(InterruptedException ex) { } 

   acct.withdraw(amt); 

   System.out.println(Thread.currentThread( ).getName( )+ " completes the withdrawal");

   } 

  else 

  { 

   System.out.println("Not enough in account for "+ Thread.currentThread().getName() + " to withdraw "+ acct.getBalance());

  } 

 }
}

class Account 

{ 

 private int balance = 50;

 public int getBalance() { return balance; }

 public void withdraw(int amount) { balance = balance - amount; }

}

In the above sample just add the word "synchronized" to the makeWithdrawal method like "private synchronized void makeWithdrawal" , because it is in this method we call another method that access and modify the variable balance.

Else if you have wrote these operations within the run() method , just put those operation code within the synchronized block like this.

public void run()

{
synchronized(this)
{
//code for the operation goes here
}
}

Points to remember :

1.Synchronization is a proccess of locking the object , so that others dont access it.
2.Others can access only , if the thread releases that object
3.Only methods (or blocks) can be synchronized, not variables or classes
4.It is not necessary that all methods should be synchronized
5.The thread doesnot releases the object even it goes to sleep state.
6.Each object just has one lock.
7.A thread can acquire more than one lock , when it invokes a synchronized method of another object.