Java中线程状态有哪些 图解线程生命周期的六种状态

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线程状态详解：深入理解并发编程的基石

线程状态是理解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 状态的转换。通过运行这段代码，可以更直观地理解线程状态的转换过程。