In-depth analysis of Java multithreading: understanding thread state transitions and inter-thread communication

Java multi-threading principle analysis: thread state transition and inter-thread communication

In Java, multi-thread programming is a common method to achieve parallel computing and improve Program performance. Multi-threaded programming can make full use of the multi-core capabilities of the computer, allowing the program to perform multiple tasks at the same time. However, writing multithreaded programs correctly and ensuring their correctness and performance is a relatively complex task.

This article will analyze the principles of Java multi-threading, focusing on thread state transitions and communication between threads. Concrete code examples are provided to illustrate these concepts.

1. Thread state transition

In Java, the state of a thread is represented by the State enumeration type in the Thread class. Common thread states include the following:

1.1 New (New): When the thread object is created but the start() method has not been called, the thread is in the new state.

1.2 Runnable: After calling the start() method, the thread is in a runnable state. Threads in this state may be waiting for CPU scheduling execution.

1.3 Blocked: The thread may suspend execution because it is waiting for a resource or some blocking situation occurs. For example, when a thread calls the sleep() method or waits for a lock on an object, the thread will enter a blocking state.

1.4 Waiting: The thread may enter the waiting state by calling the wait() method in the Object class. Threads in the waiting state need to wait for notifications from other threads before they can continue execution. For example, when a thread waits for a certain condition to be met.

1.5 Timed Waiting: Similar to the waiting state, but with a timeout. The thread can wait for the specified time, and if the timeout is reached, the thread will wake up automatically.

1.6 Terminated: After the thread completes the task or terminates abnormally, it enters the terminated state.

The state transition of the thread is shown in the figure below:

           |
           V
New -> Runnable -> Blocked -> Runnable -> Terminated
           |    ^        |
           V    |        |
        Waiting <-       |
           |    |
           V    |
   Timed Waiting <---

The following is a simple sample code showing the thread state transition process:

public class ThreadStateExample {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000); // 线程进入Timed Waiting状态
                synchronized (ThreadStateExample.class) { // 线程进入Blocked状态
                    ThreadStateExample.class.wait(); // 线程进入Waiting状态
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("Thread state: " + thread.getState()); // NEW
        thread.start();
        System.out.println("Thread state: " + thread.getState()); // RUNNABLE
        Thread.sleep(200); // 让线程有足够的时间进入Timed Waiting状态
        System.out.println("Thread state: " + thread.getState()); // TIMED_WAITING
        Thread.sleep(1000); // 让线程有足够的时间进入Waiting状态
        System.out.println("Thread state: " + thread.getState()); // WAITING
        synchronized (ThreadStateExample.class) {
            ThreadStateExample.class.notify(); // 唤醒线程
        }
        Thread.sleep(200);
        System.out.println("Thread state: " + thread.getState()); // BLOCKED
        thread.join();
        System.out.println("Thread state: " + thread.getState()); // TERMINATED
    }
}

2. Between threads Communication

In multi-threaded programming, inter-thread communication is an important technology. Inter-thread communication can realize cooperation between threads, allowing threads to execute tasks in an orderly manner.

Java provides a wealth of inter-thread communication methods, including shared memory, wait/notify mechanism, semaphore, monitor, etc. Among them, the most common way is to achieve inter-thread communication through shared objects.

Shared objects are usually objects that can be accessed by multiple threads. Data exchange and collaboration between threads can be achieved by reading and writing shared objects.

The following is a simple sample code that shows the way of communication between threads:

public class ThreadCommunicationExample {
    static class SharedObject {
        private int value;
        private boolean isValueReady;

        public synchronized int getValue() {
            while (!isValueReady) {
                try {
                    wait(); // 等待value准备好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return value;
        }

        public synchronized void setValue(int value) {
            this.value = value;
            isValueReady = true; // 设置value准备好的标记
            notify(); // 唤醒等待的线程
        }
    }

    public static void main(String[] args) {
        SharedObject sharedObject = new SharedObject();

        Thread readerThread = new Thread(() -> {
            int value = sharedObject.getValue();
            System.out.println("The value is: " + value);
        });

        Thread writerThread = new Thread(() -> {
            int value = 42;
            sharedObject.setValue(value);
        });

        readerThread.start();
        writerThread.start();
    }
}

In the above code, the communication between threads is realized through a shared object sharedObject communication. The readerThread thread waits for the value to be ready before reading the value, and the writerThread thread sets the value of the value. When the value is ready, the readerThread thread is awakened and reads the value of the value.

Through the above analysis of thread state transitions and inter-thread communication, we can better understand and use Java multi-threaded programming. At the same time, we need to pay attention to the synchronization and locking mechanisms in multi-threaded programming, as well as avoiding deadlocks and thread safety issues. Reasonable use of multi-threading technology can better improve program performance and response speed.

The above is the detailed content of In-depth analysis of Java multithreading: understanding thread state transitions and inter-thread communication. For more information, please follow other related articles on the PHP Chinese website!