Java makes working with threads relatively straight forward. However, there are situations, or anomalies that can arise due to improper design of a thread-based code. The following provides you with a list of terms and definitions for such situations.
Deadlock occurs when some threads are blocked to acquire resources held by other blocked threads. A deadlock may arise due to a dependence between two or more threads that request resources and two or more threads that hold those resources.
In Java, thread deadlock can occur:
1. When two threads call Thread.join() on one another.
2. When two threads use nested synchronized blocks to lock two objects and the blocks lock the same objects in different order.
Livelock occurs when all threads are blocked, or are otherwise unable to proceed due to unavailability of required resources, and the non-existence of any unblocked thread to make those resources available.
In Java, thread livelock can occur:
1. When all the threads in a program execute Object.wait(0) on an object
with zero parameter. The program is live-locked and cannot proceed until one
or more threads call Object.notify() or Object.notifyAll() on the relevant
objects. Because all the threads are blocked, neither call can be made.
2. When all the threads in a program are stuck in infinite loops.
Starvation occurs when one thread cannot access the CPU because one or more other threads are monopolizing the CPU.
In Java, thread starvation can be caused by setting thread priorities inappropriately. A lower-priority thread can be starved by higher-priority threads if the higher-priority threads do not yield control of the CPU from time to time.
Thrashing occurs when a program makes little-to-no progress because threads perform excessive context switching. This may leave little or no time for the application (or applet) code to execute.
Thread death occurs when the Thread.stop() method is called on a running thread. This causes the virtual machine to throw the ThreadDeath exception and eventually terminate the thread.
Thread leak occurs when resources are not reclaimed because a thread was created, but not run.