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.

Creating and Starting Threads

Join the 1M+ learners on CodeSignal

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

Java

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new RunnableDemo("Thread-1"));
        Thread t2 = new Thread(new RunnableDemo("Thread-2"));
        t1.start();
        t2.start();
    }
}

Java

public void run() {
    try {
        System.out.println("Running " + threadName);
        Thread.sleep(1000); // Sleep for 1 second
    } catch (InterruptedException e) {
        System.out.println(threadName + " interrupted.");
    }
}

Java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new RunnableDemo("Thread-1"));
        t1.start();
        t1.join(); // Wait for t1 to finish
        Thread t2 = new Thread(new RunnableDemo("Thread-2"));
        t2.start();
    }
}

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();
    }
}

Java

public void run() {
    System.out.println("Running " + threadName);
    // When this method ends, the thread will be TERMINATED
}

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();
    }
}

Thread Lifecycle and Basic Operations

What You'll Learn

Thread Lifecycle

Creating and Starting Threads

Join the 1M+ learners on CodeSignal

The Sleep Method

The Join Method

Entering the BLOCKED State

Terminating Threads

Setting Priority

The Importance of Thread Lifecycle and Operations