Understanding Life Cycle of Thread in Java, With Examples

by

Shutterstock.com / Joyseulay

Understanding how high-level things are executed is useful when working with their dynamics. You can manage threads, including their flow, interaction, and synchronization, in Java by understanding their life cycle.

Where do you even start, then? We discuss threads and their patterns in this article. You now have a place to build from. We even give a sample syntax so that you can observe the life cycle in action. So let’s continue below to learn more about threads and their workings.

What is the Life Cycle of Thread in Java

It’s crucial to comprehend what a thread actually is before we can discuss its life cycle in Java. This phrase designates a particular program’s flow of execution. Each thread has its own local variables, program counter, stack, and capability to run pathways independently.

Using shared information and constructions, threads can cooperate. Java has a wide variety of APIs, making it simple to work with these. As a result, it’s crucial to comprehend the Java thread life cycle as it relates to the execution of each concurrent thread. Let’s read on to understand more about it.

How Does the Life Cycle Work?

Although each execution flow in the program operates separately, they all have a similar life cycle. Although certain threads have distinctive states or modifications, the typical pattern is as follows:

  1. New
  2. Runnable
  3. Running
  4. Terminated

We are starting over with the thread at the new stage. Even though it’s not yet ready to run, it is now part of the code.

We have used the start() method in the runnable stage. The thread is now eligible even though it hasn’t yet been put into action. When you’re ready to use it, you can call on the thread.

The thread is used throughout the running stage.

The thread either completed its task or was given a stop method during the terminated stage. A thread cannot restart once it reaches the terminated stage. So that your threads stop when intended, it’s crucial to understand the termination requirements of your threads.

We’ve developed a thread that prints out its current status in the example below. This code can be used to track a thread’s development throughout its life cycle.

public class ThreadLifecycleExample {
    public static void main(String[] args) {
        // Create a new thread
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        
        // Start the thread
        thread.start();
        
        // Get the current state of the thread
        Thread.State state = thread.getState();
        System.out.println("Thread state after start: " + state);
        
        // Wait for the thread to complete execution
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // Get the state of the thread after it has completed
        state = thread.getState();
        System.out.println("Thread state after completion: " + state);
    }
}

There are more variations in addition to the standard thread life cycle in Java. For instance, scheduled waiting implies that a thread must wait for a certain amount of time. Or, if low-level synchronization is used to suspend a thread, you might discover that it has been parked. Additional special case states consist of:

  • Blocked/Waiting
  • Terminated but Not Garbage Collected
  • Interrupted

Leave a Comment