Java线程生命周期详解

蔚落 2024-03-16 19:44 19阅读 0赞

####  ####

*  前言
 *   *  一、线程的生命周期
     *  二、线程状态转换
     *  三、线程生命周期示例
     *  结束语

## 前言 ##

Java中的线程生命周期是多线程开发的核心概念。了解线程的生命周期以及它们如何进行状态转换对于编写有效且无错误的多线程程序至关重要。

### 一、线程的生命周期 ###

Java线程主要有以下几个状态，这些状态定义在Thread.State枚举类中：

1.  **新建状态（New）**：当我们创建一个新的线程实例时，线程就处于新建状态。这时候线程的`start()`方法还未被调用，线程对象还未开始执行。在这个状态下，Java虚拟机（JVM）已经为此线程分配了必要的内存。
    
        Thread t = new Thread(); // 线程此时处于New状态
2.  **就绪状态（Runnable）**：当线程对象调用了`start()`方法后，该线程就处于就绪状态。就绪状态的线程在获得CPU时间片后就可以开始运行。这个状态的线程位于可运行线程池中，等待被线程调度选中，获得CPU的使用权。
    
        t.start(); // 线程此时处于Runnable状态
3.  **运行状态（Running）**：线程获取到CPU时间片后，就进入运行状态，开始执行`run()`方法中的代码。值得注意的是，代码执行的实际速度和效率与处理器的速度以及多核处理器的核数有关。
    
        public void run() {
              
            System.out.println("Thread is running.");
        }
        // 如果此时这个方法正在执行，那么线程就处于Running状态
4.  **阻塞状态（Blocked）**：当一个线程试图获取一个内部的对象锁（也就是进入一个`synchronized`块），而该锁被其他线程持有，则该线程进入阻塞状态。阻塞状态的线程在锁被释放时，将会进入就绪状态。
    
        synchronized(object) {
              
            // 如果此时object的锁被其他线程持有，那么线程就处于Blocked状态
        }
5.  **等待状态（Waiting）**：线程通过调用其自身的`wait()`方法、`join()`方法或`LockSupport.park()`方法，或者通过调用其他线程的`join()`方法，可以进入等待状态。在等待状态的线程不会被分配CPU时间片，它们只能通过被其他线程显式唤醒进入就绪状态。
    
        t.wait();  // 线程此时处于Waiting状态
        t.join();  // 线程此时处于Waiting状态
6.  **超时等待状态（Timed Waiting）**：当线程调用了`sleep(long ms)`，`wait(long ms)`，`join(long ms)`，或者`LockSupport.parkNanos()`, `LockSupport.parkUntil()`等具有指定等待时间的方法，线程就会进入超时等待状态。当超时时间到达后，线程会自动返回到就绪状态。
    
        Thread.sleep(1000); // 线程此时处于Timed Waiting状态
7.  **终止状态（Terminated）**：当线程的`run()`方法执行完毕，或者线程中断，线程就会进入终止状态。在这个状态下，线程已经完成了它的全部工作。
    
        // 当run()方法执行完毕，线程处于Terminated状态
        public void run() {
              
            System.out.println("Thread is running.");
        }

这些状态之间的转换，通过各种方法的调用来实现。接下来我们将看到这些状态转换的具体情况。

### 二、线程状态转换 ###

![在这里插入图片描述][56fdeaf67d93402b93cedd1125092473.png_pic_center]

线程状态的转换是非常重要的一部分，了解状态之间的转换有助于我们更好地理解和掌握线程的行为。下面，我们来看看Java中各种线程状态的转换情况。

1.  **新建状态转就绪状态**：当线程对象被创建后，其进入新建状态。此时，通过调用线程对象的`start()`方法，可以让线程进入就绪状态，等待系统的线程调度器进行调度。
    
        Thread t = new Thread(); // 新建状态
        t.start(); // 调用start()方法，线程进入就绪状态
2.  **就绪状态转运行状态**：线程调度器从就绪队列中选择一个线程，分配给它CPU资源，这个线程就由就绪状态变为运行状态。
3.  **运行状态转就绪状态**：当一个运行状态的线程调用了`yield()`方法，或者该线程的运行时间超过了系统规定的时间片，线程就会释放CPU资源，自己由运行状态变回就绪状态，重新等待系统调度。
    
        Thread.yield(); // 调用yield()方法，线程从运行状态进入就绪状态
4.  **运行状态转阻塞状态**：当一个运行状态的线程试图获取一个被其他线程持有的对象锁时，该线程就会进入阻塞状态。
    
        synchronized(object) {
              
            // 如果此时object的锁被其他线程持有，那么线程就从运行状态进入阻塞状态
        }
5.  **阻塞状态转就绪状态**：当一个阻塞状态的线程获取到了被其他线程释放的对象锁，该线程就由阻塞状态变为就绪状态，重新等待系统调度。
6.  **运行状态转等待状态**：当一个运行状态的线程调用了`wait()`，`join()`或`LockSupport.park()`方法时，该线程就会进入等待状态。等待状态的线程需要依赖其他线程的通知才能够返回到就绪状态。
    
        t.wait(); // 调用wait()方法，线程从运行状态进入等待状态
        t.join(); // 调用join()方法，线程从运行状态进入等待状态
7.  **等待状态转就绪状态**：当一个等待状态的线程被其他线程调用`notify()`或`notifyAll()`唤醒，或者被其他线程中断，或者等待的时间到期，该线程就由等待状态转为就绪状态。
    
        t.notify(); // notify()方法被调用，线程从等待状态进入就绪状态
8.  **运行状态转超时等待状态**：当一个运行状态的线程调用了具有超时参数的`sleep()`，`wait()`，`join()`，或`LockSupport.parkNanos()`，`LockSupport.parkUntil()`方法时，该线程就会进入超时等待状态。
    
        Thread.sleep(1000); // 调用sleep()方法，线程从运行状态进入超时等待状态
9.  **超时等待状态转就绪状态**：当一个超时等待状态的线程等待的时间到期，或者被其他线程唤醒或中断，该线程就由超时等待状态转为就绪状态。
10. **任何状态转终止状态**：当线程完成任务或者因异常退出时，就会进入终止状态。

通过了解以上线程的状态转换，可以更加深入理解线程的运行机制，为多线程编程提供理论基础。

### 三、线程生命周期示例 ###

下面的Java代码实例演示了一个线程从创建到终止的整个过程：

// 创建一个继承了Thread类的ExampleThread类
    class ExampleThread extends Thread {
        
        private Object lock; // 创建一个私有的Object对象，它将在同步代码块中被使用作为锁
    
        // 构造函数，接受一个Object类型的参数
        public ExampleThread(Object lock) {
        
            this.lock = lock; // 将传入的对象赋值给lock
        }
    
        // 重写Thread类的run方法
        @Override
        public void run() {
        
            // 同步代码块，只有获取到lock对象的锁才能执行
            synchronized(lock) {
        
                try {
        
                    // 输出线程名和状态
                    System.out.println(Thread.currentThread().getName() + " is running");
                    // 让线程睡眠1秒，此时线程进入TIMED_WAITING状态
                    Thread.sleep(1000);
    
                    // 输出线程名和状态
                    System.out.println(Thread.currentThread().getName() + " is waiting");
                    // 调用wait()方法，线程释放lock锁，进入WAITING状态
                    lock.wait();
    
                    // 线程被唤醒，获取到lock锁，输出线程名和状态
                    System.out.println(Thread.currentThread().getName() + " is running again");
                } catch (InterruptedException e) {
        
                    // 线程被中断，输出线程名和状态，然后线程将结束
                    System.out.println(Thread.currentThread().getName() + " is interrupted and will terminate");
                }
            }
        }
    }
    
    public class Main {
        
        public static void main(String[] args) throws InterruptedException {
        
            // 创建一个共享的锁对象
            Object lock = new Object();
    
            // 创建一个新的线程（NEW状态）
            Thread t1 = new ExampleThread(lock);
            System.out.println(t1.getName() + " is created");
    
            // 启动新的线程（READY/RUNNABLE状态）
            t1.start();
    
            // 让主线程睡眠2秒，这样新线程就可以先运行
            Thread.sleep(2000);
    
            // 唤醒等待的线程（将进入READY/RUNNABLE状态）
            synchronized(lock) {
        
                lock.notify();
            }
    
            // 让主线程再睡眠1秒，这样被唤醒的线程可以完成运行
            Thread.sleep(1000);
        }
    }

这个代码示例演示了Java线程从创建（NEW状态），到就绪和运行（READY/RUNNABLE状态），再到等待（WAITING状态），被唤醒后再次运行，最后终止（TERMINATED状态）的整个过程。  
以优化应用的性能。

### 结束语 ###

希望以上内容能帮助你理解Java线程的生命周期。理解线程生命周期对于编写并发程序和进行多线程编程都十分重要。记住，最好的学习方法就是动手实践。因此，我鼓励大家自己动手尝试上述代码，更深入地理解线程生命周期的每个阶段。

[56fdeaf67d93402b93cedd1125092473.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/7042192d5f0743c2abdb4b3f6b0ad79d.png