Scribd
Upload
76 views7 pages

Java Thread Life Cycle Explained

The document explains the life cycle of a thread in Java, detailing the various states a thread goes through: New, Runnable, Waiting, Timed Waiting, and Terminated. It includes examples demonstrating these states through code snippets that illustrate thread creation, execution, and state transitions. Additionally, it provides output examples to show the state changes during thread execution.

Uploaded by

Ayush Jha
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
76 views7 pages

Java Thread Life Cycle Explained

The document explains the life cycle of a thread in Java, detailing the various states a thread goes through: New, Runnable, Waiting, Timed Waiting, and Terminated. It includes examples demonstrating these states through code snippets that illustrate thread creation, execution, and state transitions. Additionally, it provides output examples to show the state changes during thread execution.

Uploaded by

Ayush Jha
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Page 1 of 8

Home Whiteboard AI Assistant Online Compilers Jobs Tools Articles

SQL HTML CSS Javascript Python Java C C++ PHP Scala C# Tailwin

Java - Thread Life Cycle

Life Cycle of a Thread in Java


The life cycle of a thread in Java refers to the various states of a thread goes through. For
example, a thread is born, started, runs, and then dies. Thread class defines the life cycle and
various states of a thread.

Flow Chart of Java Thread Life Cycle


The following diagram shows the complete life cycle of a thread.

States of a Thread Life Cycle in Java


Following are the stages of the life cycle −

New − A new thread begins its life cycle in the new state. It remains in this state until the
program starts the thread. It is also referred to as a born thread.
Page 2 of 8
Runnable − After a newly born thread is started, the thread becomes runnable. A thread
in this state is considered to be executing its task.

Waiting − Sometimes, a thread transitions to the waiting state while the thread waits for
another thread to perform a task. A thread transitions back to the runnable state only when
another thread signals the waiting thread to continue executing.

Timed Waiting − A runnable thread can enter the timed waiting state for a specified
interval of time. A thread in this state transitions back to the runnable state when that time
interval expires or when the event it is waiting for occurs.

Terminated (Dead) − A runnable thread enters the terminated state when it completes
its task or otherwise terminates.

Java Example for Demonstrating Thread States


In this example, we're creating two threads by extending the Thread class. We're printing each
state of the thread. When a thread object is created, its state is NEW; when start() method is
called, state is START; when run() method is called, state is RUNNING; When a thread finished the
processing the run() method, it went to DEAD state.

Open Compiler

package [Link];
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
[Link]("Thread: " + threadName + ", " + "State: New");
}
public void run() {
[Link]("Thread: " + threadName + ", " + "State: Running");
for(int i = 4; i > 0; i--) {
[Link]("Thread:
Chapters " + threadName + ", " + i); Categories
}
[Link]("Thread: " + threadName + ", " + "State: Dead");
}
public void start () {
[Link]("Thread: " + threadName + ", " + "State: Start");
if (t == null) {
t = new Thread (this, threadName);
[Link] ();
}
}
}
Page 3 of 8
public class TestThread {
public static void main(String args[]) {
ThreadDemo thread1 = new ThreadDemo( "Thread-1");
ThreadDemo thread2 = new ThreadDemo( "Thread-2");
[Link]();
[Link]();
}
}

Output

Thread: Thread-1, State: New


Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, 3
Thread: Thread-2, 2
Thread: Thread-2, 1
Thread: Thread-2, State: Dead
Thread: Thread-1, 4
Thread: Thread-1, 3
Thread: Thread-1, 2
Thread: Thread-1, 1
Thread: Thread-1, State: Dead

More Examples on Thread Life Cycle & States

Example 1

In this example,we're using sleep() method to introduce some delay in processing and to show
case the parallel processing using threads. We're creating two threads by extending the Thread
class. We're printing each state of the thread. When a thread object is created, its state is NEW;
when start() method is called, state is START; when run() method is called, state is RUNNING; in
case sleep() is called, then thread goes to WAITING state; When a thread finished the processing
the run() method, it went to DEAD state.

Open Compiler
Page 4 of 8

package [Link];
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
[Link]("Thread: " + threadName + ", " + "State: New");
}
public void run() {
[Link]("Thread: " + threadName + ", " + "State: Running");
try {
for(int i = 4; i > 0; i--) {
[Link]("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
[Link]("Thread: " + threadName + ", " + "State: Waiting");
[Link](50);
}
} catch (InterruptedException e) {
[Link]("Thread " + threadName + " interrupted.");
}
[Link]("Thread: " + threadName + ", " + "State: Dead");
}

public void start () {


[Link]("Thread: " + threadName + ", " + "State: Start");
if (t == null) {
t = new Thread (this, threadName);
[Link] ();
}
}
}
public class TestThread {
public static void main(String args[]) {
ThreadDemo thread1 = new ThreadDemo( "Thread-1");
ThreadDemo thread2 = new ThreadDemo( "Thread-2");
[Link]();
[Link]();
}
}

Output
Page 5 of 8

Thread: Thread-1, State: New


Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-1, 4
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, State: Waiting
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, State: Waiting
Thread: Thread-1, State: Waiting
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Waiting
Thread: Thread-2, 1
Thread: Thread-2, State: Waiting
Thread: Thread-1, 1
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Dead
Thread: Thread-1, State: Dead

Example 2

In this example, we're creating two threads by implementing the Runnable class. We're printing
each state of the thread. When a thread object is created, its state is NEW; when start() method is
called, state is START; when run() method is called, state is RUNNING; in case sleep() is called,
then thread goes to WAITING state; When a thread finished the processing the run() method, it
went to DEAD state.

Open Compiler

package [Link];
class ThreadDemo implements Runnable {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
[Link]("Thread: " + threadName + ", " + "State: New");
Page 6 of 8
}
public void run() {
[Link]("Thread: " + threadName + ", " + "State: Running");
try {
for(int i = 4; i > 0; i--) {
[Link]("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
[Link]("Thread: " + threadName + ", " + "State: Waiting");
[Link](50);
}
} catch (InterruptedException e) {
[Link]("Thread " + threadName + " interrupted.");
}
[Link]("Thread: " + threadName + ", " + "State: Dead");
}

public void start () {


[Link]("Thread: " + threadName + ", " + "State: Start");
if (t == null) {
t = new Thread (this, threadName);
[Link] ();
}
}
}
public class TestThread {
public static void main(String args[]) {
ThreadDemo thread1 = new ThreadDemo( "Thread-1");
ThreadDemo thread2 = new ThreadDemo( "Thread-2");
[Link]();
[Link]();
}
}

Output

Thread: Thread-1, State: New


Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-1, 4
Thread: Thread-1, State: Waiting
Page 7 of 8
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, State: Waiting
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, State: Waiting
Thread: Thread-1, State: Waiting
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Waiting
Thread: Thread-2, 1
Thread: Thread-2, State: Waiting
Thread: Thread-1, 1
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Dead
Thread: Thread-1, State: Dead

TOP TUTORIALS TRENDING TECHNOLOGIES

Python Tutorial Cloud Computing Tutorial


Java Tutorial Amazon Web Services Tutorial
C++ Tutorial Microsoft Azure Tutorial

C Programming Tutorial Git Tutorial


C# Tutorial Ethical Hacking Tutorial
PHP Tutorial Docker Tutorial

R Tutorial Kubernetes Tutorial


HTML Tutorial DSA Tutorial
CSS Tutorial Spring Boot Tutorial

JavaScript Tutorial SDLC Tutorial


SQL Tutorial Unix Tutorial

CERTIFICATIONS COMPILERS & EDITORS

Business Analytics Certification Online Java Compiler


Java & Spring Boot Advanced Certification Online Python Compiler

Data Science Advanced Certification Online Go Compiler


Cloud Computing And DevOps Online C Compiler
Advanced Certification In Business Analytics Online C++ Compiler

Artificial Intelligence And Machine Learning Online C# Compiler

Common questions

Powered by AI

In Java, exceptions during thread execution must be caught and managed within the run() method; otherwise, they cause the thread to terminate abruptly, leading to improper state transitions and potential data inconsistencies. Effective exception handling is critical for maintaining execution flow and stability, preserving resources, and ensuring the application's overall resilience against partial task failures .

The start() method is crucial for initiating a thread's separate call stack, placing it in the RUNNABLE state, while directly calling run() executes the method on the current thread without initiating a new one, keeping it within the main thread's context. Proper use of start() is essential for concurrency and efficient resource usage, ensuring separate execution paths .

Implementing the Runnable interface and extending the Thread class both facilitate the creation of threads, but they differ in design. Runnable is preferred for better separation of thread management from the task to be performed, allowing a class to inherit from other classes besides Thread. The thread state management remains largely similar; 'NEW', 'RUNNABLE', 'WAITING', and 'DEAD' states apply in both scenarios, but the encapsulation benefits make Runnable preferable in complex systems .

Managing threads from the NEW to RUNNING states requires careful invocation of the start() method to ensure threads are correctly moved to a RUNNABLE state. Best practices include thorough control over thread initialization, avoiding complex operations in the constructor of the thread class, and separating task logic within run() to maintain readability and manage states properly .

The WAITING state is integral for managing Java threads in scenarios requiring communication between threads. It allows a thread to pause and yield resources until another thread sends a signal. This facilitates coordinated operations, prevents resource contention, and ensures threads do not consume resources unnecessarily while awaiting a task's completion .

In the Java thread life cycle, 'NEW' is the state after a thread object is created but before it is started. 'RUNNABLE' is when a thread is able to run but is not necessarily executing. 'WAITING' occurs when a thread is temporarily inactive, waiting for another thread's action, and 'DEAD' implies that the thread has finished executing or has been terminated .

Time delays from the sleep() method facilitate better management of processor time by yielding control, allowing other threads to execute. It impacts thread interaction by reducing priority inversion and helping maintain a responsive system. However, improperly managed, it can lead to difficult-to-trace bugs affecting execution order and overall performance .

The sleep() method in Java causes a running thread to go into a WAITING state for a specified time. This temporarily halts the execution of the thread and allows other threads to execute, which can be advantageous in multi-threading environments to manage processor time efficiently and avoid resource contention .

Transitioning to the TERMINATED state signifies that a thread has fully completed its operation or execution, which can affect other threads reliant on its completion. Threads previously in WAITING for a TERMINATED thread may resume execution, moving to RUNNABLE. This affects thread synchronization and continuation of dependent processes .

The core lifecycle stages (NEW, RUNNABLE, WAITING, DEAD) remain unchanged whether using the Thread class or the Runnable interface for thread execution. However, implementing Runnable is more flexible, allowing for inheritance from other classes and potentially better design through separation of concerns. The ability to decouple the task (run() method) from thread management is beneficial in complex systems .

You might also like