Threads are one of the most important concepts in Java programming. They allow us to run multiple tasks simultaneously, which can improve the performance of our applications. However, it’s important to understand the Java thread lifecycle in order to use them effectively.
In this blog post, we will discuss the different states that a thread can be in, and how it can move between these states. We will also discuss some of the events that can cause a thread to change state.
Let’s understand the following image first.
A thread in Java can be in one of the following states:
New
This is the state that a thread is in when we create an instance of Thread class but before the invocation of start() method.
Runnable
The thread is in runnable state after invocation of start() method, but the thread scheduler has not selected it to be the running thread. So basically, this is the state after calling the start() method and before calling the run() method.
Running
The thread is in running state if the thread scheduler has selected it and called a run() method.
Blocked
This is the state when the thread is still alive, but is currently not running or not eligible to run.
Terminated
A thread is in terminated or dead state when its run() method exits. This is the end of the thread lifecycle in Java.
A thread can move between states in a number of ways. For example, a thread can move from the New state to the Runnable state when the start() method is called on it. A thread can move from the Runnable state to the Blocked state when it tries to acquire a lock on a shared resource that is already locked by another thread. A thread can move from the Runnable state to the Waiting state when it calls the wait() method.
FAQs
What is the Java thread lifecycle?
The Java thread lifecycle represents the various states a thread can be in during its execution. These states include new, runnable, running, blocked, and terminated.
What is the “New” state in the thread lifecycle?
The “New” state is the initial state of a thread. In this state, the thread is created, but it has not yet started its execution.
How does a thread transition from the “New” state to the “Runnable” state?
A thread transitions from the “New” state to the “Runnable” state when the start() method is called on the thread object. This method initiates the thread’s execution.
What causes a thread to enter the “Blocked” state?
A thread enters the “Blocked” state when it’s waiting for a resource that’s currently held by another thread. It will remain in this state until the resource becomes available.
How does a thread enter the “Terminated” state?
A thread enters the “Terminated” state when its run() method finishes executing or when it’s explicitly terminated using the Thread class’s interrupt() or stop() methods.
Can a thread transition from “Terminated” back to any other state?
No, once a thread is in the “Terminated” state, it cannot return to any other state in the thread lifecycle. It has completed its execution.