4.1.2 Thread States Explained

Understanding the different states of a thread is crucial for managing concurrent operations in Java. A thread in Java can exist in several states, each representing a different phase of its lifecycle. Mastering these states allows developers to effectively control and optimize thread behavior.

Key Concepts

1. New

A thread is in the New state when it has been created but not yet started. In this state, the thread is not yet alive and has not begun executing its task.

Example

        Thread myThread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        // myThread is in the New state
    

2. Runnable

A thread transitions to the Runnable state when the start() method is called. In this state, the thread is eligible to run, but it may or may not be actively executing due to the scheduler's discretion.

Example

        myThread.start();
        // myThread is in the Runnable state
    

3. Blocked

A thread enters the Blocked state when it is waiting to acquire a lock to enter a synchronized block or method. This state occurs when another thread holds the lock that the current thread needs.

Example

        synchronized (lock) {
            // Thread may transition to Blocked state if lock is held by another thread
        }
    

4. Waiting

A thread is in the Waiting state when it is waiting indefinitely for another thread to perform a particular action. This state can be entered using methods like wait().

Example

        synchronized (lock) {
            try {
                lock.wait();
                // Thread is in the Waiting state
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    

5. Timed Waiting

A thread is in the Timed Waiting state when it is waiting for a specified period. This state can be entered using methods like sleep(long millis) or wait(long timeout).

Example

        try {
            Thread.sleep(1000);
            // Thread is in the Timed Waiting state for 1 second
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    

6. Terminated

A thread enters the Terminated state when it has completed its execution or has been explicitly terminated. In this state, the thread is no longer alive.

Example

        myThread.join();
        // myThread has completed its execution and is in the Terminated state
    

Examples and Analogies

Think of a thread's lifecycle as a journey through different phases of a task. The New state is like preparing a task but not starting it yet. The Runnable state is like being ready to start the task, but waiting for your turn. The Blocked state is like waiting for a tool that another task is using. The Waiting state is like waiting for someone else to finish their part. The Timed Waiting state is like setting a timer for a break. The Terminated state is like completing the task and finishing the journey.

By understanding these states, you can better manage and optimize concurrent operations in your Java SE 11 applications, ensuring efficient and effective thread management.