Java线程生命周期：Java线程生命周期全景解读

标签：状态生命周期 Java Thread System 线程 println out

1. 线程生命周期概述：不仅仅是状态转换

在多线程编程中，理解线程的生命周期对于编写有效、高效的代码至关重要。线程生命周期通常描述了线程从创建到死亡的一系列状态变化过程，但其实不仅仅局限于这些状态的简单转换。线程生命周期的理解应该考虑系统资源的分配、线程调度、同步、通信，以及在这些状态转换中所涉及的复杂机制。在现代操作系统中，线程生命周期涉及的五个基本状态分别是：

新建 (New)
就绪 (Runnable)
运行 (Running)
阻塞 (Blocked)
死亡 (Terminated)

然而，操作系统和JVM的线程调度策略、同步机制（如锁）、等待/通知模式以及线程自身的方法调用，都会对这些状态产生影响，使得线程的生命周期变得更加复杂。本文将探讨Java中线程生命周期的每个状态，并通过丰富的实例代码展示它们之间的转换是如何发生的，以及程序员需要在实际编程工作中注意哪些问题。

以下是一个基本线程生命周期的Java代码示例：

public class ThreadLifeCycleExample implements Runnable {

    public void run() {
        // 线程处于运行状态时的逻辑处理
        try {
            // 模拟线程执行任务
            Thread.sleep(1000);
            // 线程可能处于TIMED_WAITING状态，因为调用了sleep方法
        } catch (InterruptedException e) {
            // 对中断异常的处理
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadLifeCycleExample());
        
        // 在这点，线程处于 NEW 状态
        System.out.println("Thread state after creation: " + thread.getState());

        thread.start();
        // 启动线程后，线程处于 RUNNABLE 状态（在Java中RUNNABLE包含了就绪和运行状态）
        System.out.println("Thread state after calling .start(): " + thread.getState());

        // 主线程暂停，确保上面的线程运行
        Thread.sleep(100);
        System.out.println("Thread state after calling .sleep() in main: " + thread.getState());

        // 等待线程终止
        thread.join();
        System.out.println("Thread state after completion: " + thread.getState());
    }
}

2. 深入Java线程状态

file 线程在Java中是通过Thread类来实现的，它封装了线程的状态以及行为。根据Java线程生命周期，线程可以存在于以下几种状态之一：

新建 (NEW)
可运行 (RUNNABLE)
阻塞 (BLOCKED)
等待 (WAITING)
计时等待 (TIMED_WAITING)
终止 (TERMINATED)

这些状态在java.lang.Thread.State枚举中有定义。接下来，我们将深入分析每个状态。

2.1. NEW：线程的诞生

一个线程在被创建出来，但是还没有调用start()方法之前，处于NEW状态。此时，它被实例化但尚未开始执行。

2.2. RUNNABLE：准备运行的双面性

在Java编程中，RUNNABLE状态实际上包含了传统意义上的"可运行"和"运行"两种状态。即线程已经被启动且可以被线程调度器执行（可运行），或已经在执行了（运行）。然而，即使线程处于RUNNABLE状态，是否正在执行由操作系统的线程调度器决定。

2.3. BLOCKED与WAITING：阻塞与等待的微妙差别

BLOCKED状态通常发生在线程试图获取一个锁时，但该锁正被其他线程持有。WAITING状态发生于等待其他线程特定的通知（notification）时，例如调用了Object.wait()方法，而没有任何时间限制。

2.4. TIMED_WAITING：带有时限的挂起

线程可以通过调用一些带有指定等待时间的方法（如Thread.sleep(long millis)或Object.wait(long timeout)）进入TIMED_WAITING状态，这意味着线程在一个特定的时间之后会自动返回RUNNABLE状态。

2.5. TERMINATED：终结并非终点

一旦线程的run()方法执行完毕，或者线程被中断，它就会进入TERMINATED状态。线程一旦终结，它的生命周期就结束了，不能重新启动。

3. 详细分析线程状态转换

理解线程状态之间的转换对于管理线程生命周期至关重要。这些状态转换可能会受代码逻辑、线程管理API的使用以及操作系统调度策略的影响。在这一章节，我们将详细探讨各个转换点，并通过实际案例来演示它们是如何在Java中实现的。

3.1. 如何从NEW到RUNNABLE：线程的启动

当一个线程被创建时，它首先处于NEW状态。一旦调用了线程对象的start()方法，该线程被移动到RUNNABLE状态，并等待线程调度器的调度执行。以下是一个示例代码：

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
});
System.out.println("State after thread creation: " + thread.getState());  // 应打印 NEW
thread.start();
System.out.println("State after calling start(): " + thread.getState());  // 应打印 RUNNABLE

3.2. RUNNABLE与BLOCKED的拮抗：同步造成的结果

一个线程的状态从RUNNABLE变为BLOCKED通常是因为它试图获得一个已被其他线程锁定的对象锁。这里展示了如何使用synchronized关键字来演示这个转换：

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(BlockedStateDemo::run);
        Thread t2 = new Thread(BlockedStateDemo::run);

        t1.start();
        t2.start();
        
        Thread.sleep(10);  // 确保线程 t1 运行起来
        System.out.println("State of t2 after attempting to enter synchronized block: " + t2.getState());
        // 应打印 BLOCKED
    }

    private static void run() {
        synchronized (lock) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

3.3. RUNNABLE到WAITING的过渡：对象监视器模型

当线程需要等待其他线程执行某个特定操作时，它会进入WAITING状态。一个典型的例子是调用Object类的wait()方法：

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(WaitingStateDemo::run);
        t1.start();
        Thread.sleep(10);  // 给 t1 时间达到 wait() 调用
        System.out.println("State of t1: " + t1.getState()); // 应该打印 WAITING
    }

    private static void run() {
        synchronized (lock) {
            try {
                lock.wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

3.4. WAITING到TIMED WAITING的条件：时间控制的等待

与WAITING状态相似，TIMED_WAITING状态涉及一个时间的概念。当线程调用一个带有指定等待时间的方法时，它会进入此状态，例如Thread.sleep(long millis)：

public class TimedWaitingStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        t1.start();
        Thread.sleep(10);  // 给 t1 一点时间进入 sleep
        System.out.println("State of t1 after calling sleep(): " + t1.getState()); // 应打印 TIMED_WAITING
    }
}

3.5. 从RUNNABLE到TERMINATED状态：线程的结束

一旦线程的run()方法执行完毕或者它被中断，它就会进入TERMINATED状态：

public class TerminatedStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            // 无任务，直接退出
        });
        t1.start();
        t1.join(); // 等待 t1 结束
        System.out.println("State of t1 after it has finished execution: " + t1.getState()); // 打印 TERMINATED
    }
}

4. 线程状态转换的实战案例分析

在这一章节，我们将通过几个编程案例，详细展示线程状态的转换，并解释在这些状态转换中可能遇到的问题。这将帮助开发人员更好地掌握线程状态管理，并避免常见的多线程编程陷阱。

4.1. 状态转换演示：编写示例代码解释状态转换

我们将首先展示一个简单的案例，这个案例会创建多个线程，并模拟阻塞、等待和超时等待的场景，来观察和理解线程状态的转换。

示例代码：

public class ThreadStateTransitionDemo {

    private static final Object LOCK = new Object();

    public static void main(String[] args) throws Exception {
        // 新建一个线程，它会进行一段时间的计时等待
        Thread timedWaitingThread = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 新建一个线程，它会无限期等待直到获得锁
        Thread waitingThread = new Thread(() -> {
            synchronized (LOCK) {
                try {
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 新建一个线程，尝试获取锁，但是会被 waitingThread 阻塞
        Thread blockedThread = new Thread(() -> {
            synchronized (LOCK) {
                System.out.println("Blocked Thread 获取到了锁");
            }
        });

        System.out.println("启动各个状态的线程...");
        timedWaitingThread.start();
        waitingThread.start();
        Thread.sleep(100); // 确保 waitingThread 运行并进入 waiting 状态
        blockedThread.start();
        Thread.sleep(100); // 短暂等待，让线程尝试获取锁

        System.out.println("TimedWaitingThread 状态: " + timedWaitingThread.getState());
        System.out.println("WaitingThread 状态: " + waitingThread.getState());
        System.out.println("BlockedThread 状态: " + blockedThread.getState());

        // 发起通知，让 waitingThread 退出等待状态
        synchronized (LOCK) {
            LOCK.notify();
        }

        // 等待所有线程完成
        timedWaitingThread.join();
        waitingThread.join();
        blockedThread.join();

        System.out.println("所有线程都完成了执行。");
    }
}

这段代码首先创建了三个线程，它们分别模拟了计时等待（timed waiting）、无限期等待（waiting）以及阻塞（blocked）三种状态。通过调用 getState() 方法，我们可以查看每个线程的状态，然后触发状态转换进行验证。

4.2. 实例解析：挖掘阻塞、等待和超时等待的场景

接下来，我们通过上面的代码来解说不同状态下的线程是如何响应的。这有助于开发者理解在并发编程中如何正确处理同步和线程协调的关键部分。

4.3. 死锁与线程生命周期的关联

最后，我们将展示一个引入死锁的示例来说明线程状态管理如果不当，可能会导致应用程序无响应的情况。死锁的情形通常涉及两个或两个以上的线程，它们彼此等待对方释放锁，但却永远不会发生，因此线程将保持阻塞状态。

示意代码：

public class DeadlockDemo {
    private static final Object RESOURCE1 = new Object();
    private static final Object RESOURCE2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (RESOURCE1) {
                System.out.println("Thread 1: Locked resource 1");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (RESOURCE2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (RESOURCE2) {
                System.out.println("Thread 2: Locked resource 2");

                synchronized (RESOURCE1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        }).start();
    }
}

代码中，两个线程互相持有对方需要的资源，且都在等待对方释放资源。这种情况就是典型的死锁。

5. 性能监控与线程状态：工具与实践

了解和监控Java线程的状态对于确保应用程序性能至关重要。本章节将介绍几种常用的工具，这些工具可以帮助开发者监控和分析线程的行为和状态，从而进行性能优化和故障排查。

5.1. 使用JConsole监控线程状态

JConsole是Java开发者工具箱中的标准工具，它可以通过JMX（Java Management Extensions）连接到运行中的Java应用程序，提供应用程序的实时监控数据，其中包括线程的状态信息。当您想要查看和监控线程状态时，可启动JConsole并连接到您的Java应用程序。它将提供一个线程标签页，显示所有活动线程的列表和它们当前的状态，包括锁持有情况，以及死锁探测器等有用信息。使用JConsole监控线程状态的步骤大致如下：

启动Java应用程序，确保在启动参数中开启JMX端口。
启动JConsole并连接到相应的JMX端口。
在'线程'标签页中观察线程状态和其他关键信息。

5.2. 借助VisualVM进行线程性能剖析

VisualVM是另一款强大的监控工具，它不仅能监控线程状态，还能提供CPU和内存的实时数据，线程转储，以及性能分析（Profiler）等功能。通过VisualVM，开发者可以很容易地捕获线程转储（thread dump），分析应用程序中的线程是如何互相作用的，识别出性能瓶颈或不必要的同步操作。 VisualVM使用的基本步骤如下：

启动VisualVM。
选择要监控的Java应用程序。
查看'线程'标签，进行线程的实时监控或者捕获线程转储。

5.3. 编程避坑：线程状态不当转换导致的性能问题

在多线程编程中，不恰当的线程状态转换可能会导致严重的性能问题，如过度的线程创建和销毁、频繁的上下文切换、死锁和资源饥饿等。开发人员需学会使用以上工具诊断这些问题，并采取适当策略来优化代码，比如正确的同步策略，合理的线程池使用，以及有效的线程通信机制等。

标签：状态,生命周期,Java,Thread,System,线程,println,out
From： https://blog.51cto.com/xfishup/10803869