Java中线程的生命周期

青旅半醒 2023-09-23 14:24 93阅读 0赞

## 1 介绍 ##

本篇文章我们讨论下Java中的一个非常核心的概念：线程的生命周期。在Java编程语言中，多线程编程非常重要。线程从创建到销毁是有生命周期的，在线程的生命周期中，线程会经历多种状态(state)。

## 2 线程状态说明以及状态流转图 ##

`java.lang.Thread`类中有一个静态的枚举类：`State`，用来表示线程各种可能的状态：

public enum State {
            /**
             * NEW状态表示线程新创建，仍不能开始运行。
             */
            NEW,
    
            /**
             * RUNNABLE表示线程可运行(runnable or ready to run)，有可能正在运行，或者正在资源ready，比如CPU调度。
             */
            RUNNABLE,
    
            /**
             * BLOCKED表示线程正在等待监视器锁(monitor lock)，获取到监视器锁后可以进入同步代码块或者同步方法(synchronized block/method)，当然可能是首次等待，也可能是调用Object.wait()等待之后再被唤醒(Object.notify()或者Object.notifyAll())后，因为唤醒后一般不能直接进入Runnable状态，需要重写争抢监视器锁，这时仍然是BLOCKED状态。
             */
            BLOCKED,
    
            /**
             * WAITING状态表示当前线程正在等待其他线程的一些动作(无超时时间的等待)，包括如下三个场景：
             * Object.wait()调用之后等待其他线程调用Object.notify()或者Object.notifyAll()
             * Thread.join()调用之后等待指定的线程终止(进入TERMINATED状态)
             * LockSupport.park()调用之后等待等待其他线程调用LockSupport.unpark(thread)
             */
            WAITING,
    
            /**
             * TIMED_WAITING状态表示当前线程在限定时间内等待其他线程的一些动作，包括如下几个场景：
             * Thread.sleep
             * Object.wait指定等待时间
             * Thread.join指定等待时间
             * LockSupport.parkNanos
             * LockSupport.parkUntil
             */
            TIMED_WAITING,
    
            /**
             * TERMINATED表示终止状态，线程已经执行完成。
             */
            TERMINATED;
        }
    复制代码

线程的可能状态流转图(状态机)如下所示：

![format_png][]

注意上面的`Blocked`状态，线程调用`Object.wait()`等待之后会进入`WAITING`或`TIMED_WAITING`状态，而再被唤醒(`Object.notify()`或者`Object.notifyAll()`)后，由于唤醒后一般不能直接进入`Runnable`状态，需要重写争抢监视器锁，这时仍然是先进入`BLOCKED`状态。

## 3 线程各状态实战举例 ##

### 3.1 NEW ###

`NEW`状态表示线程新创建，仍不能开始运行。当调用了线程的`start()`方法后线程才开始运行。下面的代码表示新创建的线程处于`NEW`状态：

Runnable runnable = new Runnable() {
      @Override
      public void run() {
        System.out.println("线程任务运行中...");
      }
    };
    Thread thread = new Thread(runnable);
    System.out.println(thread.getState());
    复制代码

运行结果如下：

![format_png 1][]

### 3.2 Runnable ###

`RUNNABLE`表示线程可运行(runnable or ready to run)，**有可能正在运行，或者正在资源ready，比如CPU调度**。在多线程环境下，JVM中的线程调度器给每个线程分配一定的时间片去执行，执行完分配的之后之后，换为其他线程执行(分时复用机制)。我们继续基于前面的代码，把线程启动起来，然后看下线程的状态：

Runnable runnable = new Runnable() {
      @Override
      public void run() {
        System.out.println("线程任务运行中...");
      }
    };
    Thread thread = new Thread(runnable);
    thread.start();
    System.out.println(thread.getState());
    复制代码

运行结果如下：

![format_png 2][]

有一点需要注意：由于线程启动之后可能非常快就直接执行完，因此可能输出`TERMINATED`状态。

### 3.3 Blocked ###

当一个线程等待获取监视器锁(monitor lock)的时候，会处于`BLOCKED`状态，之所以要等待获取监视器锁，是因为当前监视器锁正在被其他线程占有。下面我们复现该线程状态：

public class TestMain {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(new DemoBlockedRunnable());
            Thread t2 = new Thread(new DemoBlockedRunnable());
            t1.start();
            t2.start();
            Thread.sleep(1000);
            System.out.println(t2.getState());
            System.exit(0);
        }
    }
    
    class DemoBlockedRunnable implements Runnable {
        @Override
        public void run() {
            commonResource();
        }
    
        public static synchronized void commonResource() {
            while(true) {
                // Infinite loop to mimic heavy processing
                // 't1' won't leave this method
                // when 't2' try to enter this
            }
        }
    }
    复制代码

输出如下：

![format_png 3][]

上述代码中，由于`t1`先抢占了`类DemoBlockedRunnable`上的监视器锁，并且`t1`进入了无限循环，导致`t2`一直在等待获取监视器锁，因此打印`t2`的线程状态为`BLOCKED`。

### 3.4 Waiting ###

WAITING状态表示当前线程正在等待其他线程的一些动作(无超时时间的等待)，包括如下三个场景：

1.  object.wait()调用之后等待其他线程调用Object.notify()或者Object.notifyAll()；
2.  thread.join()调用之后等待指定的线程终止(进入TERMINATED状态)；
3.  LockSupport.park()调用之后等待等待其他线程调用LockSupport.unpark(thread)；

下面我们复现该线程状态：

public class TestMain {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(new Runnable1());
            Thread t2 = new Thread(new Runnable2(t1));
            t1.start();
            t2.start();
            Thread.sleep(1000);
            System.out.println(t2.getState());
        }
    }
    
    class Runnable1 implements Runnable {
        @Override
        public void run() {
            System.out.println("Runnable1 begin run...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Runnable1 end run...");
        }
    }
    
    class Runnable2 implements Runnable {
        private Thread runnable1;
        public Runnable2(Thread runnable1) {
            this.runnable1 = runnable1;
        }
        @Override
        public void run() {
            System.out.println("Runnable2 begin run...");
            try {
                runnable1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Runnable2 end run...");
        }
    }
    复制代码

输出如下：

![format_png 4][]

这里由于线程`t2`调用了`thread.join()`，因此陷入`WAITING`状态。

### 3.5 Timed Waiting ###

TIMED\_WAITING状态表示当前线程在限定时间内等待其他线程的一些动作，包括如下几个场景：

1.  Thread.sleep(long mills)
2.  object.wait(int timeout)
3.  thread.join(long mills)
4.  LockSupport.parkNanos
5.  LockSupport.parkUntil

public class TestMain {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t1.start();
            Thread.sleep(1000);
            System.out.println(t1.getState());
        }
    }
    复制代码

输出如下：

![format_png 5][]

这里由于线程`t1`调用了`Thread.sleep(2000)`，因此在等待期内的状态为`TIMED_WAITING`。

### 3.6 Terminated ###

`TERMINATED`是线程终止状态，线程完成执行或者异常终止后都会处于`TERMINATED`状态。

public class TestMain {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("t1 running begin..");
                    System.out.println("t1 running end..");
                }
            });
            t1.start();
            Thread.sleep(1000);
            System.out.println(t1.getState());
        }
    }
    复制代码

输出如下：

![format_png 6][]

## 4 总结 ##

线程是Java多线程编程的基础，本文讨论了Java中线程的生命周期，以及生命周期中可能出现的6种状态，每种状态都举例进行了说明。

[format_png]: https://img-blog.csdnimg.cn/img_convert/d71480ef475891f691137cc527c43dcf.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/ef5da968cc7a4f77b372ab7bd68671ce.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/3daacd51b1e3a89657aa03ee67011540.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/969c9772196df1601f931b961db9db5e.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/08c59481ae97f9d9d60c641901e0b0ce.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/6a193991694edb1ea55082f481854e25.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/fdb7e3df80aa20fe44539309f63ac9ef.webp?x-oss-process=image/format,png