Thread Foundations and Lifecycle Mechanics

Threads are the smallest units of execution in concurrent programming. Before diving into locks and high-level utilities, one must fundamentally understand the thread itself: how it is created, scheduled, and how its states transition under the JVM's hood.

1. Defining Tasks vs. Creating Threads

While there are multiple ways to define a task, there is essentially only one way to create a thread in Java: new Thread().start().

1.1 Runnable vs. Callable

• Runnable: Defines a task with no return value (void) and no checked exceptions.
• Callable: Returns a generic result V and can throw checked exceptions.
• FutureTask: A bridge that wraps a Callable, implements Runnable, and stores the result for later retrieval via get().

1.2 The "Start0" Reality

Calling run() is just a normal method call in the current thread. Only start() triggers the JVM's native start0() method, which calls the OS-specific API (like pthread_create on Linux) to allocate a new kernel thread and its 1MB stack.

2. The 6 States of a Java Thread

The Thread.State enum defines a thread's lifecycle in the eyes of the JVM:

1. NEW: Object created, but start() not yet called.
2. RUNNABLE: Executing or waiting for a CPU time slice. (Java groups "Ready" and "Running" into one state).
3. BLOCKED: Waiting specifically for a synchronized lock.
4. WAITING: Infinite wait for another thread (via wait(), join(), or LockSupport.park()).
5. TIMED_WAITING: Wait with a timeout (via sleep(ms), wait(ms), or parkNanos()).
6. TERMINATED: Execution finished or crashed.

State Transition Matrix

3. High-Frequency Mechanics: sleep() vs. wait()

This is a common architectural comparison, but the logic is structural:

• Thread.sleep(ms): A static method. The thread sleeps but keeps all its locks. It is a "pause" in execution.
• Object.wait(): An instance method. The thread releases the object's lock and joins the wait-set.
• The synchronized Requirement: wait() must be called inside a synchronized block for that object. This ensures the condition check and the "release-and-wait" action is atomic, preventing Lost Wakeups.

4. The Collaborative Interrupt

Java deprecated Thread.stop() because it was unsafe—it killed threads instantly, potentially leaving shared data in an inconsistent state (e.g., mid-transaction).

The modern solution is Interruption:

• Signal: thread.interrupt() sets an internal flag.
• Response: The thread checks Thread.currentThread().isInterrupted() and shuts down gracefully.
• Exception: If a thread is blocked in sleep() or wait(), it will immediately wake up and throw an InterruptedException, giving it a chance to clean up resources before exiting.

5. Daemon Threads: The Background Guards

A thread can be marked as a Daemon (setDaemon(true)).

• JVM behavior: The JVM will exit automatically once all non-daemon threads (user threads) have finished, even if daemon threads are still running.
• Common examples: Garbage Collector (GC), JIT compiler, or heartbeat monitors.