[JavaSE Column 76] Three-state and five-state, different states of threads: new, running, state, blocking, waiting, timing waiting state

Thread state transitions are managed by the JVM and the operating system, and developers cannot directly control and predict thread state transitions. Therefore, when writing multi-threaded programs, students need to correctly handle the state transition of threads to avoid potential concurrency problems and deadlocks.

The following are some sample codes for the five-state transition of Java threads, please copy and execute them locally.

3.1 Transition from new state to running state

Thread thread = new Thread(() -> {<!-- -->
    // tasks to be executed by the thread
});
thread.start(); // Start the thread, the thread transitions from the new state to the running state

3.2 Transition from running state to blocking state

public class MyRunnable implements Runnable {<!-- -->
    private Object lock;

    public MyRunnable(Object lock) {<!-- -->
        this. lock = lock;
    }

    @Override
    public void run() {<!-- -->
        synchronized (lock) {<!-- -->
            // critical section code
            try {<!-- -->
                Thread.sleep(1000); // The thread sleeps and enters the blocked state
            } catch (InterruptedException e) {<!-- -->
                e.printStackTrace();
            }
        }
    }
}

public class Main {<!-- -->
    public static void main(String[] args) {<!-- -->
        Object lock = new Object();
        Thread thread1 = new Thread(new MyRunnable(lock));
        Thread thread2 = new Thread(new MyRunnable(lock));
        thread1. start();
        thread2.start();
    }
}

3.3 Transition from running state to waiting state

public class MyRunnable implements Runnable {<!-- -->
    private Object lock;

    public MyRunnable(Object lock) {<!-- -->
        this. lock = lock;
    }

    @Override
    public void run() {<!-- -->
        synchronized (lock) {<!-- -->
            try {<!-- -->
                lock.wait(); // thread enters waiting state
            } catch (InterruptedException e) {<!-- -->
                e.printStackTrace();
            }
        }
    }
}

public class Main {<!-- -->
    public static void main(String[] args) {<!-- -->
        Object lock = new Object();
        Thread thread = new Thread(new MyRunnable(lock));
        thread. start();
    }
}

3.4 Transition from running state to timing waiting state

public class MyRunnable implements Runnable {<!-- -->
    @Override
    public void run() {<!-- -->
        try {<!-- -->
            Thread.sleep(2000); // The thread sleeps and enters the timing waiting state
        } catch (InterruptedException e) {<!-- -->
            e.printStackTrace();
        }
    }
}

public class Main {<!-- -->
    public static void main(String[] args) {<!-- -->
        Thread thread = new Thread(new MyRunnable());
        thread. start();
    }
}

3.5 Transition from running state to terminated state

public class MyRunnable implements Runnable {<!-- -->
    @Override
    public void run() {<!-- -->
        // tasks to be executed by the thread
    }
}

public class Main {<!-- -->
    public static void main(String[] args) {<!-- -->
        Thread thread = new Thread(new MyRunnable());
        thread. start();
        // Wait for the thread to finish executing, and the thread transitions from the running state to the terminated state
        try {<!-- -->
            thread. join();
        } catch (InterruptedException e) {<!-- -->
            e.printStackTrace();
        }
    }
}

The above are sample codes of some common Java thread five-state transitions, which implement transitions between states by triggering different methods or operations. In practical applications, students need to flexibly use different states of threads according to specific needs and situations to achieve the goal of concurrent programming.

4. Application scenarios of five states

The five states of threads in Java can play a role in different application scenarios. The following are some common application scenarios, please study carefully.

1. New state: The state after the thread object is created but before the start() method is called. This state is suitable for thread preparation, such as allocating resources for threads, initializing variables, and so on.
2. Running state: The state entered after the thread is started, the thread is executing the tasks in the run() method. In concurrent programming, multiple running threads can be used to perform different tasks at the same time, improving the throughput and responsiveness of the system.
3. Blocked state: The thread cannot execute for some reason and enters the blocked state. This state is suitable for waiting for external resources, waiting for locks, or waiting for other threads to complete some operations. For example, when a thread needs to access a shared resource, if the resource is already occupied by other threads, the current thread will enter a blocked state until the resource is released.
4. Waiting state: The thread calls the wait() method of the Object class or the join() method of the Thread class to enter the waiting state. This state is suitable for coordination and communication between threads. For example, a thread waits for other threads to complete some operations before proceeding.
5. Timing waiting state: The thread calls the sleep(long millis) method of the Thread class or the wait(long timeout) method of the Object class, and enters the timing waiting state. This state is suitable for scenarios where you want the thread to pause for a period of time before continuing to execute.

The flexible conversion and reasonable use of these states can realize the cooperation between threads, the sharing and utilization of resources, and improve the concurrent performance and response speed of the program. But it should be noted that for multi-threaded programming, thread safety and synchronization issues need to be paid attention to to avoid uncertain results and race conditions.

5. JAVA five-state interview questions

1. Please explain what are the five states of a thread in Java?
2. How to transition a thread from new state to running state in Java?
3. Under what circumstances will a thread change from a running state to a blocked state?
4. What are wait states and timed wait states? What's the difference between them?
5. How to transition a thread from running state to waiting state or timed waiting state?
6. How to transition a thread from waiting state or timed waiting state to running state?
7. Under what circumstances will a thread transition from the running state to the terminated state?
8. In Java, how to properly handle state transitions of threads to avoid potential concurrency issues?

6. Summary

This article explains the concepts of three-state and five-state in Java, introduces the application scenarios of new, running, status, blocking, waiting, and timing waiting states, and gives sample codes. In the next blog, I will explain how Java Implement thread creation and startup.