Thread Lifecycle and Basic Operations

Welcome to the next step in our journey into Java concurrency . In this lesson, we will delve deeply into the lifecycle of a thread and explore some fundamental thread operations. By the end of this lesson, you will have a firm grasp of thread states, lifecycle management, and how to use essential thread methods to control their behavior.

What You'll Learn

In this lesson, you'll explore: The different states in the lifecycle of a thread. Key thread methods such as start(), sleep(), join(), and setPriority() . Practical insights into thread priorities and how they affect thread scheduling. By the end of this lesson, you will understand how to manage thread lifecycles effectively and use different thread operations to build efficient multithreaded applications.

Thread Lifecycle

In Java, a thread can exist in one of several states throughout its lifecycle. Understanding these states is crucial to designing and debugging multithreaded applications effectively: NEW: The thread is created but not yet started. RUNNABLE: The thread is ready to run and is waiting for CPU time. BLOCKED: The thread is waiting for a monitor lock to enter or re-enter a synchronized block/method. For instance, if multiple threads are trying to access the same synchronized method, they may be blocked until they acquire the lock. WAITING: The thread is waiting indefinitely for another thread to perform a particular action. TIMED_WAITING: The thread is waiting for another thread to perform a particular action for a specified waiting time. TERMINATED: The thread has completed its execution, either because it has run to completion or because an exception has occurred that has terminated the run method. Consider the following simple implementation of the Runnable interface: Javapublic class RunnableDemo implements Runnable { private String threadName; public RunnableDemo(String name) { threadName = name; } public void run() { System.out.println("Running " + threadName); } } This RunnableDemo class implements the Runnable interface and overrides the run method to print the thread's name. Now, let's use this class to understand the basic thread operations.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Entering the BLOCKED State

The BLOCKED state occurs when a thread is waiting to gain access to a resource that is being used by another thread in a synchronized block or method. We'll learn more about the synchronized keyword in the next unit, but for now, you can think of it as a mechanism that ensures only one thread can execute a particular method or block of code at a time, preventing conflicts in multi-threaded environments.

In this situation, if multiple threads try to execute the same synchronized code, only one thread can proceed, while others are temporarily blocked until the first thread finishes and releases control of the code.

Java

public class SynchronizedDemo {
    // This keyword makes sure that only one thread can access this method at a time,
    // ensuring thread safety for operations within the method
    public synchronized void printMessage(String message) {
        System.out.println(message);
    }
}

public class Main {
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        
        Runnable task = () -> {
            demo.printMessage("Hello from " + Thread.currentThread().getName());
        };
        
        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");

        t1.start();
        t2.start();
    }
}

public class SynchronizedDemo {
    // This keyword makes sure that only one thread can access this method at a time,
    // ensuring thread safety for operations within the method
    public synchronized void printMessage(String message) {
        System.out.println(message);
    }
}

public class Main {
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        
        Runnable task = () -> {
            demo.printMessage("Hello from " + Thread.currentThread().getName());
        };
        
        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");

        t1.start();
        t2.start();
    }
}

In this example, printMessage is a synchronized method. When t1 is executing this method, t2 will enter the BLOCKED state, waiting for t1 to finish before it can execute the same method.

Setting Priority

In Java, thread priorities can be set using the setPriority method, which helps guide the thread scheduler in deciding which thread to execute first. Priorities range from Thread.MIN_PRIORITY (1) to Thread.MAX_PRIORITY (10), with Thread.NORM_PRIORITY (5) as the default. By default, a thread inherits the priority of its creator.

The JVM uses a fixed-priority pre-emptive scheduling algorithm, which usually gives preference to the highest-priority thread. However, sometimes the scheduler may run lower-priority threads to avoid starvation—a situation where high-priority threads keep lower-priority threads from executing.

Java's Thread class provides:

getPriority(): Returns the current priority of the thread.
setPriority(int priority): Sets the thread's priority to a value between 1 and 10. Any value outside this range will throw an error.

Here's an example:

Java

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new RunnableDemo("High Priority Thread"));
        t1.setPriority(Thread.MAX_PRIORITY);

        Thread t2 = new Thread(new RunnableDemo("Normal Priority Thread"));
        t2.setPriority(Thread.NORM_PRIORITY);

        Thread t3 = new Thread(new RunnableDemo("Low Priority Thread"));
        t3.setPriority(Thread.MIN_PRIORITY);

        t1.start();
        t2.start();
        t3.start();
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new RunnableDemo("High Priority Thread"));
        t1.setPriority(Thread.MAX_PRIORITY);

        Thread t2 = new Thread(new RunnableDemo("Normal Priority Thread"));
        t2.setPriority(Thread.NORM_PRIORITY);

        Thread t3 = new Thread(new RunnableDemo("Low Priority Thread"));
        t3.setPriority(Thread.MIN_PRIORITY);

        t1.start();
        t2.start();
        t3.start();
    }
}

In this example, t1 is assigned maximum priority, t2 normal priority, and t3 minimum priority. The actual execution order can vary, as the behavior of thread priorities is platform-dependent. Thus, priorities are a suggestion to the JVM and not a strict guarantee of execution sequence.