Java线程6种状态全解析！一张图轻松掌握线程生命周期

想要深入理解Java并发编程？本文将带你全面解析Java线程的六种状态：NEW（新建）、RUNNABLE（可运行）、BLOCKED（阻塞）、WAITING（等待）、TIMED_WAITING（定时等待）和TERMINATED（终止），并通过一张图让你秒懂线程生命周期。掌握线程状态是诊断并发问题、优化程序性能的关键。我们将结合`jstack`命令，教你如何分析线程堆栈信息，判断线程状态，并探讨死锁的产生原因及避免方法。更有代码示例，助你直观理解线程状态转换，优化你的并发程序！

Java线程生命周期包含六种状态，分别是NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。1. NEW表示线程被创建但尚未启动；2. RUNNABLE表示线程已就绪或正在运行；3. BLOCKED表示线程因等待锁而阻塞；4. WAITING表示线程无限期等待其他线程操作；5. TIMED_WAITING表示线程在指定时间内等待；6. TERMINATED表示线程执行完毕或异常终止。理解这些状态有助于诊断并发问题并优化性能，例如通过jstack分析线程堆栈信息判断状态，同时避免死锁需破坏互斥、占有等待、不可剥夺或循环等待条件之一。

Java中的线程状态可以理解为线程在其生命周期中所处的不同阶段，从创建到消亡，线程会经历多种状态的转变。理解这些状态对于编写高效、稳定的并发程序至关重要。

解决方案

Java线程的生命周期包含六种状态：NEW（新建）、RUNNABLE（可运行）、BLOCKED（阻塞）、WAITING（等待）、TIMED_WAITING（定时等待）和TERMINATED（终止）。

Java线程状态详解：深入理解并发编程的基石

线程状态是理解Java并发编程的关键。不同的状态反映了线程与操作系统、锁、以及其他线程之间的交互情况。深入理解这些状态，能帮助我们更好地诊断并发问题，优化程序性能。

• NEW (新建)：线程被创建但尚未启动。此时线程对象已经存在，但尚未调用 start() 方法。

• RUNNABLE (可运行)：这是一个复合状态，包括了 READY (就绪) 和 RUNNING (运行中) 两种状态。READY状态表示线程已经准备好运行，等待CPU调度；RUNNING状态表示线程正在执行 run() 方法中的代码。由于操作系统调度的不确定性，线程在这两种状态之间切换是无法人为控制的。

• BLOCKED (阻塞)：线程在等待获取锁时进入阻塞状态。例如，当线程尝试进入一个被其他线程持有的 synchronized 块或方法时，就会进入 BLOCKED 状态。

• WAITING (等待)：线程无限期地等待另一个线程执行特定操作。进入 WAITING 状态的常见方式有：

  • 调用 Object.wait() 方法（不带超时参数）。
  • 调用 Thread.join() 方法（不带超时参数）。
  • 调用 LockSupport.park() 方法。

  线程可以通过以下方式退出 WAITING 状态：

  • 被 notify() 或 notifyAll() 方法唤醒。
  • 被中断（interrupt() 方法）。
  • Thread.join() 方法的等待时间结束。

• TIMED_WAITING (定时等待)：与 WAITING 状态类似，但线程会等待指定的时间。进入 TIMED_WAITING 状态的常见方式有：

  • 调用 Thread.sleep() 方法。
  • 调用 Object.wait(long timeout) 方法（带超时参数）。
  • 调用 Thread.join(long timeout) 方法（带超时参数）。
  • 调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long deadline) 方法。

  线程可以通过以下方式退出 TIMED_WAITING 状态：

  • 等待时间结束。
  • 被 notify() 或 notifyAll() 方法唤醒。
  • 被中断（interrupt() 方法）。
  • Thread.join() 方法的等待时间结束。

• TERMINATED (终止)：线程执行完毕或因异常而终止。此时线程已经结束生命周期，不能再次启动。

如何使用jstack命令分析线程状态？

jstack 是一个非常有用的命令行工具，它可以打印出指定 Java 进程的线程堆栈信息。通过分析线程堆栈信息，我们可以了解线程当前的状态，以及线程正在执行的代码。这对于诊断死锁、线程阻塞等并发问题非常有帮助。

例如，要分析进程ID为1234的Java进程，可以执行以下命令：

jstack 1234

jstack 的输出会包含每个线程的堆栈信息，其中包括线程的状态。例如：

"Thread-1" #10 prio=5 os_prio=0 tid=0x00007f9b88888000 nid=0x1a03 waiting on condition [0x00007f9b87e7f000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at com.example.MyThread.run(MyThread.java:10)
        at java.lang.Thread.run(Thread.java:745)

从上面的输出可以看出，线程 "Thread-1" 的状态是 TIMED_WAITING (sleeping)，并且正在执行 Thread.sleep() 方法。

死锁是如何产生的？如何避免？

死锁是指两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的现象。死锁的产生通常需要满足以下四个条件：

1. 互斥条件：资源必须处于独占状态，即一次只能被一个线程持有。
2. 占有且等待条件：线程已经持有一个资源，但又请求新的资源，并且在等待新资源的同时，不释放已经持有的资源。
3. 不可剥夺条件：线程已经获得的资源，在未使用完之前，不能被其他线程强行剥夺。
4. 循环等待条件：多个线程之间形成循环等待资源的关系。

要避免死锁，可以破坏上述任何一个条件。常见的避免死锁的方法有：

• 避免嵌套锁：尽量避免在一个锁的范围内请求另一个锁。
• 使用定时锁：使用 tryLock(long timeout, TimeUnit unit) 方法，在等待锁的时候设置超时时间，避免无限期等待。
• 资源排序：为所有资源定义一个全局的顺序，线程按照顺序请求资源，避免循环等待。
• 使用死锁检测工具：一些工具可以帮助检测死锁，例如 jconsole。

线程状态转换图的实际应用：优化并发程序

理解线程状态转换图对于优化并发程序至关重要。例如，如果发现大量线程处于 BLOCKED 状态，可能意味着锁竞争激烈，需要优化锁的使用方式。如果发现线程频繁在 WAITING 和 RUNNABLE 状态之间切换，可能意味着线程需要等待的条件过于频繁，需要重新设计线程间的协作方式。

通过分析线程状态，我们可以更好地理解程序的并发行为，从而找到性能瓶颈，并进行优化。

代码示例：模拟线程状态转换

以下代码演示了线程在不同状态之间的转换：

public class ThreadStateDemo {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        // NEW 状态
        Thread thread = new Thread(() -> {
            try {
                // RUNNABLE -> BLOCKED 状态
                synchronized (lock) {
                    System.out.println("Thread acquired lock.");
                    // RUNNABLE -> WAITING 状态
                    lock.wait();
                    System.out.println("Thread woke up.");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("Thread state: " + thread.getState()); // 输出 NEW

        thread.start(); // NEW -> RUNNABLE

        Thread.sleep(100);
        System.out.println("Thread state: " + thread.getState()); // 可能输出 RUNNABLE 或 BLOCKED

        // 唤醒线程
        synchronized (lock) {
            lock.notify();
        }

        Thread.sleep(100);
        System.out.println("Thread state: " + thread.getState()); // 可能输出 RUNNABLE

        thread.join(); // 等待线程结束
        System.out.println("Thread state: " + thread.getState()); // 输出 TERMINATED
    }
}

这段代码创建了一个线程，并演示了线程从 NEW 状态到 RUNNABLE 状态，再到 BLOCKED 状态，最后到 WAITING 状态的转换。通过运行这段代码，可以更直观地理解线程状态的转换过程。

到这里，我们也就讲完了《Java线程6种状态全解析！一张图轻松掌握线程生命周期》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于并发编程,死锁,线程状态,Java线程,jstack的知识点！