Confused with Synchronization

[Phillipe Rodrigues]

Hi,
I am reading the threads chapter for the first time.I tried a sample program on synchronization.Why am I getting different outputs for Example1 and Example 2. Please explain me what actually happens with the two examples.Request a spoon feeding

public class AccountBalance {
protected int balance =50;

public int getBalance()
{
return balance;
}

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

Example1:

public class AccountDanger implements Runnable {
AccountBalance acct =new AccountBalance();
public void run() {
for(int i =0;i<5;i++){
makeWithdrawl(10);
if(acct.getBalance()<0){
System.out.println("Account overdrawn");
}
}
}

public synchronized void makeWithdrawl(int amt){
int bal =acct.getBalance();
if(bal >= amt){
System.out.println(Thread.currentThread().getName()+"is going to withdrawl");
try{
Thread.sleep(500);
}catch(InterruptedException e){
e.getMessage();
}
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName()+"completes the withdrawl");
}else{
System.out.println("No enough money in account for withdrawl Mr./Mrs." +Thread.currentThread().getName()+acct.getBalance());

} 
}

 
public static void main(String[] args) {
AccountDanger danger =new AccountDanger();
AccountDanger danger1 =new AccountDanger();
Thread t1 =new Thread(danger);
Thread t2 =new Thread(danger1);
//Thread t3 =new Thread(danger);
t1.setName("Fred");
t2.setName("Lucy");
//t3.setName("Tom");
   //           t3.start();
t2.start();
t1.start();
 
}
 
}

OutPut Of Example 1:
Lucyis going to withdrawl
Fredis going to withdrawl
Fredcompletes the withdrawl
Lucycompletes the withdrawl
Fredis going to withdrawl
Lucyis going to withdrawl
Fredcompletes the withdrawl
Lucycompletes the withdrawl
Fredis going to withdrawl
Lucyis going to withdrawl
Lucycompletes the withdrawl
Fredcompletes the withdrawl
Lucyis going to withdrawl
Fredis going to withdrawl
Fredcompletes the withdrawl
Lucycompletes the withdrawl
Fredis going to withdrawl
Lucyis going to withdrawl
Lucycompletes the withdrawl
Fredcompletes the withdrawl



Example2:

 
public class AccountDanger implements Runnable {
AccountBalance acct =new AccountBalance();
public void run() {
for(int i =0;i<5;i++){
makeWithdrawl(10);
if(acct.getBalance()<0){
System.out.println("Account overdrawn");
}
}
}

public synchronized void makeWithdrawl(int amt){
int bal =acct.getBalance();
if(bal >= amt){
System.out.println(Thread.currentThread().getName()+"is going to withdrawl");
try{
Thread.sleep(500);
}catch(InterruptedException e){
e.getMessage();
}
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName()+"completes the withdrawl");
}else{
System.out.println("No enough money in account for withdrawl Mr./Mrs." +Thread.currentThread().getName()+acct.getBalance());

} 
}

 
public static void main(String[] args) {
AccountDanger danger =new AccountDanger();
//AccountDanger danger1 =new AccountDanger();
Thread t1 =new Thread(danger);
Thread t2 =new Thread(danger);
//Thread t3 =new Thread(danger);
t1.setName("Fred");
t2.setName("Lucy");
//t3.setName("Tom");
   //   t3.start();
t2.start();
t1.start();
 
}
 
}
 

Output of Example2:

Lucyis going to withdrawl
Lucycompletes the withdrawl
Fredis going to withdrawl
Fredcompletes the withdrawl
Lucyis going to withdrawl
Lucycompletes the withdrawl
Fredis going to withdrawl
Fredcompletes the withdrawl
Lucyis going to withdrawl
Lucycompletes the withdrawl
No enough money in account for withdrawl Mr./Mrs.Fred0
No enough money in account for withdrawl Mr./Mrs.Lucy0
No enough money in account for withdrawl Mr./Mrs.Fred0
No enough money in account for withdrawl Mr./Mrs.Lucy0
No enough money in account for withdrawl Mr./Mrs.Fred0




Request spoon feeding on below.


You can make a subset (or indeed all) of the methods for any class object mutually exclusive, so that only
one of the methods can execute at any given time. You make methods mutually exclusive by declaring
them in the class using the keyword synchronized.
Now, only one of the synchronized methods in a class object can execute at any one time. Only when the
currently executing synchronized method for an object has ended can another synchronized method
start for the same object. The idea here is that each synchronized method has guaranteed exclusive
access to the object while it is executing, at least so far as the other synchronized methods for the class
object are concerned.
The synchronization process makes use of an internal lock that every object has associated with it. The
lock is a kind of flag that is set by a process, referred to as locking or a lock action, when a synchronized
method starts execution. Each synchronized method for an object checks to see whether the lock has
been set by another method. If it has, it will not start execution until the lock has been reset by an unlock
action. Thus, only one synchronized method can be executing at one time, because that method will
have set the lock that prevents any other synchronized method from starting.


Note that there�s no constraint here on simultaneously executing synchronized
methods for two different objects of the same class. It�s only concurrent access to any
one object that is controlled.

[Nitesh Kant]

The example you have shown is trying to demonstrate the object that is used for synchronization when you make a method synchronized.
For a non-static synchronized method, the lock is on the instance referred by "this".
Any thread can enter a synchronized block of code if and only if it holds the lock on the specified instance(in your case "this"). Additionally, only one thread can hold a lock on an object instance at any moment of time.
This means that you can implement mutual execution exclusion for two method using synchronization.
However, for different instances of the same class, since the lock instance will be different a mutual execution exclusion is not guranteed.

Let me know if the above does not clarify your doubt.

[Phillipe Rodrigues]

Hi,
I did not get the description above.Also what is actually Example1 and Example2 doing.

[Nitesh Kant]

The only difference in Example 1 and Example 2 (atleast looking at it casually) is:
All threads in Example 1 uses different AccountDanger objects(i.e. in turn different AccountBalance objects)
On the other hand, all threads in Example 2 uses same AccountDanger object(i.e. in turn same AccountBalance objects)

Since, the makeWithdrawl method in AccountDanger is synchronized, so, at any moment of time only one thread, using the same AccountDanger, can execute this method.

In example 1, since every thread has its own AccountDanger/AccountBalance instance, all threads(Fred, Lucy ..) are able to successfully withdraw amount of 50.
In example 2, since all threads share the same AccountDanger/AccountBalance object, the amount that one can withdraw depends on whether the thread can get a lock and enter the method makeWithdrawl(). The exact amount withdrawn by each thread can not be predicted and one of the Thread will get an "Not enough money" message.

The examples are trying to demonstrate that the lock used for synchronization in a synchronized method is the object referred by the variable "this".