Starvation – Concurrency: Part I
Starvation
A thread can starve because it is unsuccessfully waiting for its turn to be able to proceed with its execution. In addition to deadlock and livelock that result in starvation, some other situations where starvation can occur are the following:
- Unfair priority scheduling: Higher-priority threads monopolize the CPU, and low-priority threads starve in the READY substate.
- Indefinite waiting for join to complete: A thread that executed a no-timeout join() call can starve in the WAITING state if the thread it is waiting for never completes.
- Indefinite waiting in the entry set of the object lock: A thread can starve in the BLOCKED state if other threads get chosen before it to acquire the object lock to enter synchronized code.
- Indefinite waiting in the wait set of an object: A thread that executed a no-timeout wait() call can starve in the WAITING state if it never gets notified. It can also starve in this state if other threads get chosen on notification before it does, and it never gets to compete for object lock acquisition.
Example 22.11 provides another example of starvation. The Hole class at (1) provides the synchronized method dig() to dig a hole. The class Diggers creates a Hole object and starts five threads to dig this hole. The output shows that the thread that first acquires the lock to execute the synchronized dig() method in the Hole object monopolizes the CPU, and the other threads do not get a chance to run—they wait and starve.
The starvation scenario in Example 22.11 can be remedied by making a thread wait between digging—implemented by the try-catch block at (3) with the call to the timed wait() method. The call to the wait() method will result in the current thread transiting to the TIMED_WAITING state and releasing the lock on the Hole object, thus making it possible for other waiting threads to run. On the other hand, a call to the sleep() method does not release the lock and will still result in thread starvation.
Example 22.11 Starvation
public class Hole { // (1)
public synchronized void dig() {
String threadName = Thread.currentThread().getName();
while (true) { // (2)
System.out.println(threadName + ” digging the hole.”);
// try { // (3)
// wait(1);
// } catch (InterruptedException ex) {
// ex.printStackTrace();
// }
}
}
}
public class Diggers {
public static void main(String[] args) {
Hole hole = new Hole(); // (4)
for (int i = 0; i < 5; i++) { // (5)
new Thread(() -> hole.dig()).start();
}
}
}
Probable output from the program:
…
Thread-0 digging the hole.
Thread-0 digging the hole.
Thread-0 digging the hole.
Thread-0 digging the hole.
Thread-0 digging the hole.
Thread-0 digging the hole.
…
