— Scott McNealy, Sun Microsystems Chairman, President and ceo

What are thread priorities? I’ve 
heard that’s a way you can control 
scheduling.
A: 
Thread priorities might help 
you influence the scheduler, but they 
still don’t offer any guarantee. Thread 
priorities are numerical values that tell 
the scheduler (if it cares) how important a 
thread is to you. In general, the scheduler 
will kick a lower priority thread out of the 
running state if a higher priority thread 
suddenly becomes runnable. But... one 
more time, say it with me now, “there 
is no guarantee.” We recommend that 
you use priorities only if you want to 
influence performance, but never, ever 
rely on them for program correctness.
Q: 
Why don’t you just synchronize 
all the getters and setters from the 
class with the data you’re trying to 
protect? Like, why couldn’t we have 
synchronized just the checkBalance() 
and withdraw() methods from class 
BankAccount, instead of synchronizing 
the makeWithdrawal() method from 
the Runnable’s class?
A: 
Actually, we should have 
synchronized those methods, to prevent 
other threads from accessing those 
methods in other ways. We didn’t bother, 
because our example didn’t have any 
other code accessing the account. 
But synchronizing the getters 
and setters (or in this case the 
checkBalance() and withdraw()) isn’t 
enough. Remember, the point of 
synchronization is to make a specific 
section of code work ATOMICALLY. In 
other words, it’s not just the individual 
methods we care about, it’s methods 
that require more than one step to 
complete! Think about it. If we had not 
synchronized the makeWithdrawal() 
method, Ryan would have checked the 
balance (by calling the synchronized 
checkBalance()), and then immediately 
exited the method and returned the key!
Of course he would grab the key again, 
after he wakes up, so that he can call 
the synchronized withdraw() method, 
but this still leaves us with the same 
problem we had before synchronization! 
Ryan can check the balance, go to sleep, 
and Monica can come in and also check 
the balance before Ryan has a chance to 
wakes up and completes his withdrawal.
So synchronizing all the access methods 
is probably a good idea, to prevent 
other threads from getting in, but you 
still need to synchronize the methods 
that have statements that must execute 
as one atomic unit.