Whenever multiple threads compete for a scarce resource, there’s a danger of starvation. Earlier we discussed this concept in the context of CPU starvation: with a bad choice of scheduling options, some threads never had the opportunity to become the currently running thread and suffered from CPU starvation.
A similar situation is theoretically possible when it comes to locks
granted by the
synchronized keyword. Lock
starvation occurs when a particular thread attempts to acquire a lock
and never succeeds because another thread is already holding the
lock. Clearly, this can occur on a simple basis if one thread
acquires the lock and never releases it: all other threads that
attempt to acquire the lock will never succeed and will starve. But
lock starvation can be more subtle than that: if there are six
threads competing for the same lock, it’s possible that each of
five threads will hold the lock for only 20% of the time, thus
starving out the sixth thread.
Like CPU starvation, lock starvation is not something most threaded Java programs need to consider. If our Java program is producing a result in a finite period of time, then eventually all threads in the program will acquire the lock, if only because all the other threads in the program have exited. But also like CPU starvation, lock starvation includes the question of fairness: there are certain times when we want to make sure that threads acquire locks in a reasonable order, so that one thread won’t necessarily ...