— Scott McNealy, Sun Microsystems Chairman, President and ceo

Every Java object has a lock. 
A lock has only one key.
Most of the time, the lock is 
unlocked and nobody cares.
But if an object has 
synchronized methods, a 
thread can enter one of the 
synchronized methods ONLY 
if the key for the object’s lock 
is available. In other words, 
only if another thread hasn’t 
already grabbed the one key.
Hey, this object’s 
takeMoney() method is 
synchronized. I need to get 
this object’s key before I 
can go in...

---

512
 
chapter 15
The dreaded “Lost Update” problem
Here’s another classic concurrency problem, that comes from the database world. It’s 
closely related to the Ryan and Monica story, but we’ll use this example to illustrate a few 
more points.
The lost update revolves around one process:
Step 1: Get the balance in the account
int i = balance;
Step 2: Add 1 to that balance
 balance = i + 1;
The trick to showing this is to force the computer to take two steps to complete the change 
to the balance. In the real world, you’d do this particular move in a single statement:
balance++;
But by forcing it into two steps, the problem with a non-atomic process will become clear. 
So imagine that rather than the trivial “get the balance and then add 1 to the current 
balance” steps, the two (or more) steps in this method are much more complex, and 
couldn’t be done in one statement.
In the “Lost Update” problem, we have two threads, both trying to increment the balance. 
class TestSync implements Runnable {
private int balance;
public void run() {
for(int i = 0; i < 50; i++) {