Java 中的线程状态：深入解析与实践指南

简介

在 Java 多线程编程中，理解线程状态（Thread States）是至关重要的。线程状态描述了线程在其生命周期内所处的不同阶段，从创建到最终消亡。通过掌握线程状态，开发者能够更好地控制线程的执行，优化程序性能，避免并发问题。本文将详细介绍 Java 中的线程状态，包括基础概念、使用方法、常见实践以及最佳实践，帮助读者全面掌握这一重要的多线程编程知识。

线程状态基础概念

Java 中的线程具有六种状态，定义在 java.lang.Thread.State 枚举中： 1. NEW：线程被创建，但尚未启动。此时线程还没有开始执行任何代码。 2. RUNNABLE：线程处于可运行状态，可能正在运行，也可能正在等待 CPU 资源。在这种状态下，线程在 Java 虚拟机（JVM）中执行，但可能在操作系统层面上处于运行或就绪状态。 3. BLOCKED：线程被阻塞，等待获取对象的监视器（锁）。当一个线程尝试进入一个被其他线程占用的同步块或方法时，它会进入 BLOCKED 状态。 4. WAITING：线程处于等待状态，等待其他线程执行特定操作。通常是调用了 Object.wait()、Thread.join() 或 LockSupport.park() 方法。 5. TIMED_WAITING：线程处于定时等待状态，在指定的时间内等待其他线程执行特定操作。例如，调用 Thread.sleep(long timeout)、Object.wait(long timeout) 或 LockSupport.parkNanos(Object blocker, long deadline) 方法。 6. TERMINATED：线程已执行完毕，生命周期结束。

线程状态的使用方法

示例代码：查看线程状态

public class ThreadStatesExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread is running: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 查看线程初始状态
        System.out.println("Thread state before start: " + thread.getState());

        thread.start();

        // 查看线程启动后的状态
        System.out.println("Thread state after start: " + thread.getState());

        try {
            // 等待线程执行完毕
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 查看线程执行完毕后的状态
        System.out.println("Thread state after join: " + thread.getState());
    }
}

代码说明

创建一个新线程并定义其执行逻辑。
在启动线程之前，使用 getState() 方法查看线程状态，此时线程处于 NEW 状态。
启动线程后，再次查看线程状态，此时线程处于 RUNNABLE 状态。
使用 join() 方法等待线程执行完毕，之后查看线程状态，此时线程处于 TERMINATED 状态。

常见实践

同步与阻塞状态

在多线程环境中，同步机制（如 synchronized 关键字）常用于保护共享资源。当一个线程进入同步块或方法时，它会获取对象的监视器（锁）。如果锁已被其他线程占用，新线程将进入 BLOCKED 状态。

public class SynchronizedExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 acquired the lock.");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 released the lock.");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 acquired the lock.");
                System.out.println("Thread 2 released the lock.");
            }
        });

        thread1.start();
        thread2.start();
    }
}

等待与通知机制

Object.wait() 和 Object.notify() 方法用于线程间的通信。一个线程可以调用 wait() 方法进入 WAITING 状态，等待其他线程调用同一对象的 notify() 或 notifyAll() 方法。

public class WaitNotifyExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 waiting...");
                    lock.wait();
                    System.out.println("Thread 1 notified.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 about to notify.");
                lock.notify();
                System.out.println("Thread 2 notified.");
            }
        });

        thread1.start();
        thread2.start();
    }
}

最佳实践

避免死锁：死锁是多线程编程中常见的问题，当两个或多个线程相互等待对方释放资源时会发生死锁。为了避免死锁，应遵循以下原则：
- 尽量减少锁的使用范围。
- 按照相同的顺序获取锁。
- 避免在持有锁的情况下调用外部不可控的代码。
合理使用等待与通知机制：在使用 wait() 和 notify() 方法时，应确保在合适的条件下进行通知，避免不必要的等待。同时，使用 wait() 方法时应在循环中检查条件，以防止虚假唤醒。
使用并发工具类：Java 提供了丰富的并发工具类，如 java.util.concurrent 包中的 CountDownLatch、CyclicBarrier 和 Semaphore 等。这些工具类可以简化多线程编程，提高代码的可读性和可靠性。

小结

本文详细介绍了 Java 中的线程状态，包括基础概念、使用方法、常见实践以及最佳实践。理解线程状态对于编写高效、稳定的多线程程序至关重要。通过合理控制线程的状态，可以避免并发问题，提高程序的性能和响应性。希望读者通过本文的学习，能够在实际的 Java 多线程编程中灵活运用线程状态知识，编写出高质量的代码。