— Scott McNealy, Sun Microsystems Chairman, President and ceo

510
 
chapter 15
We need the makeWithdrawal ( ) method 
to run as one 
atomic
thing. 
 
private 
synchronized
 void makeWithdrawal(int amount) {
if (account.getBalance() >= amount) {
System.out.println(Thread.currentThread().getName() + “ is about to withdraw”);
try {
System.out.println(Thread.currentThread().getName() + “ is going to sleep”);
Thread.sleep(500);
} catch(InterruptedException ex) {ex.printStackTrace(); }
System.out.println(Thread.currentThread().getName() + “ woke up.”);
account.withdraw(amount);
System.out.println(Thread.currentThread().getName() + “ completes the withdrawl”);
} else {
System.out.println(“Sorry, not enough for “ + Thread.currentThread().getName());
}
 }
The 
synchronized 
keyword means that 
a thread needs a key 
in order to access the 
synchronized code.
To protect your 
data 
(like the bank account), 
synchronize the 
methods that act on 
that data.
We need to make sure that once a thread enters the 
makeWithdrawal() method, it must be allowed to finish the method 
before any other thread can enter.
In other words, we need to make sure that once a thread has 
checked the account balance, that thread has a guarantee that it can 
wake up and finish the withdrawal before any other thread can check the 
account balance!
Use the 
synchronized 
keyword to modify a method so that only 
one thread at a time can access it.
That’s how you protect the bank account! You don’t put a lock on 
the bank account itself; you lock the method that does the banking 
transaction. That way, one thread gets to complete the whole 
transaction, start to finish, even if that thread falls asleep in the 
middle of the method!
So if you don’t lock the back account, then what exactly 
is locked? Is 
it the method? The Runnable object? The thread itself?
We’ll look at that on the next page. In code, though, it’s quite 
simple—just add the synchronized modifier to your method 
declaration:
(Note for you physics-savvy readers: yes, the convention of using the word ‘atomic’ here does not reflect 
the whole subatomic parcticle thing. Think Newton, not Einstein, when you hear the word ‘atomic’ in the 
context of threads or transactions. Hey, it’s not OUR convention. If WE were in charge, we’d apply 
Heisenberg’s Uncertainty Principle to pretty much everything related to threads.)