Thread Lifecycle & Thread Methods

#Introduction

A thread moves through a fixed set of states from creation to termination. Knowing them — and the methods that move a thread between them — is essential for reading thread dumps, diagnosing hung applications and answering one of the most common interview questions.

#The Six Thread States

Thread.getState() returns one of the values of the Thread.State enum:

From RUNNABLE, a thread can temporarily leave and come back:

Thread t = new Thread(() -> sleepQuietly(500));
System.out.println(t.getState());   // NEW
t.start();
Thread.sleep(100);
System.out.println(t.getState());   // TIMED_WAITING
t.join();
System.out.println(t.getState());   // TERMINATED

#sleep()

Thread.sleep(ms) pauses the current thread for at least the given time:

try {
    Thread.sleep(2000);   // TIMED_WAITING for ~2 seconds
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();   // restore the interrupt flag
}

• It's a static method — someOtherThread.sleep(1000) still sleeps the current thread.
• It does not release any locks the thread holds.
• The actual pause can be longer than requested (scheduling), never meaningfully shorter.

#join()

join() makes the current thread wait until another thread finishes:

Thread loader = new Thread(() -> loadCache(), "cache-loader");
loader.start();

loader.join();          // main waits here (WAITING)
startServer();          // runs only after the cache is loaded

loader.join(5000);      // or wait at most 5 seconds (TIMED_WAITING)

#yield()

Thread.yield() hints that the current thread is willing to give up the CPU so other runnable threads can run. The scheduler is free to ignore it. It's almost never needed in application code — don't use it for coordination.

#Interrupting Threads

Java has no safe way to forcibly kill a thread (Thread.stop() is deprecated because it could leave objects half-updated, and since Java 20 it just throws UnsupportedOperationException). Instead, threads are cancelled cooperatively using the interrupt flag.

worker.interrupt();   // sets worker's interrupt flag — a polite request to stop

What happens next depends on what the target thread is doing:

Writing an Interruptible Task

Runnable poller = () -> {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            pollQueue();
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();   // restore the flag…
            break;                                // …and exit
        }
    }
    System.out.println("Poller stopped cleanly");
};

// ❌ Swallowed — the interrupt is lost
catch (InterruptedException e) { }

// ✅ Restore the flag
catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

#sleep() vs wait()

A classic interview question:

#Other Useful Methods

#Reading Thread States in a Thread Dump

When an application hangs, take a thread dump (jstack <pid>, jcmd <pid> Thread.print, or the Actuator /threaddump endpoint):

"http-nio-8080-exec-7" #45 daemon prio=5 os_prio=0 tid=0x... nid=0x... waiting for monitor entry
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.shop.InventoryService.reserve(InventoryService.java:42)
        - waiting to lock <0x00000000c1a2b3c4> (a com.shop.Inventory)

#Key Takeaways

• A thread is in one of six states: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED.
• sleep() keeps locks; wait() releases the monitor.
• join() waits for another thread to finish.
• Threads are stopped cooperatively with interrupt(); tasks must respond to it.
• Thread dumps show each thread's state and the lock it's waiting for.