Java线程状态（生命周期）--一篇入魂

逃离我推掉我的手 2023-10-03 18:50 19阅读 0赞

### 1.线程状态（生命周期） ###

一个线程在给定的时间点只能处于一种状态。

线程可以有如下6 种状态：

*  New (新创建）：未启动的线程；
 *  Runnable (可运行）：可运行的线程，需要等待操作系统资源；
 *  Blocked (被阻塞）：等待监视器锁而被阻塞的线程；
 *  Waiting (等待）：等待唤醒状态，无限期地等待另一个线程唤醒；
 *  Timed waiting (计时等待）：在指定的等待时间内等待另一个线程执行操作的线程；
 *  Terminated (被终止）：已退出的线程。

要确定一个线程的当前状态， 可调用getState 方法

**线程状态关系图**

注意：虚线框（全大写英文）的状态为Java线程状态。

![image][]

### 2.操作线程状态 ###

#### 2.1.新创建状态（NEW） ####

就是实例化线程完成后，未启动线程的状态。

可通过三种方式创建线程

*  重写Thread类run()方法
 *  实现Runnable接口
 *  实现Callable接口

一个简单的例子概括三种方式

public class Demo {
        
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            /**
             * 1.直接重写run() 或继承Thread类再重写run()
             */
            Thread thread = new Thread() {
        
                @Override
                public void run() {
        
                    System.out.println("Thread");
                }
            };
            // 开启线程
            thread.start();
    
            /**
             * 2.lambda、内部类或线程类方式实现Runnable接口，实现run()方法
             * 再交给Thread 类
             */
            Thread runThread = new Thread(() -> {
        
                System.out.println("Runnable");
            });
            // 开启线程
            runThread.start();
    
            /**
             * 3.lambda、内部类或线程类方式实现Callable接口，实现call()方法
             * 再交给Thread 类：FutureTask本质也是Runnable实现类
             */
            FutureTask<String> futureTask = new FutureTask<String>(() -> {
        
                System.out.println("Callable");
                return "CallableThread";
            });
            Thread callThread = new Thread(futureTask);
            // 开启线程
            callThread.start();
            // 获取call()方法的返回值
            String s = futureTask.get();
            System.out.println("call()方法的返回值："+s);
        }
    
    }

不重写 run() 或 call() 方法直接实例化Thread类创建的线程没有实际意义；

只有Callable方式创建的线程可以获取线程的返回值。

#### 2.2.可运行状态（RUNNABLE） ####

该状态指的是线程实例化对象调用start()方法后进入的状态。线程处于可以运行状态，如果有处理器等资源，就可以执行程序。

该状态在**操作系统层面**包含两步：线程就绪和线程运行中，但在Java线程状态中，这两步都统称为Runnable（可运行）状态。

线程由就绪状态变为运行状态，重点就看你的线程有没有抢到CPU资源（CPU时间片），谁抢到就运行，没抢到就等。因为CPU时间片（执行时间）非常短，大概十几毫秒，所以线程切换的这个时间是非常短的，就绪状态变为运行状态的时间也非常短，在开发时几乎感觉不到这种状态的变化，所以在Java中将两者看作是一个整体，重点关注线程可否运行并区别于其他状态即可，更进一步简化线程的开发。如果你的程序要运行很久（比如写个死循环），在一个CPU时间片内没有执行完成，那么你的线程就要抢下一次的CPU时间片，抢到了才可以继续执行程序，没抢到那就要继续抢，直到线程中的程序执行完成。

其实这个场景应该都见到过，例如多个线程执行同一个程序，都将日志打印到同一个文件时，就会出现不同线程的日志混在了一起的情况，不利于排查问题。解决这种问题常见的方法有：一是分线程打印日志到不同文件；二是将日志信息保存到字符串对象中，在程序的最后将日志信息一次性打印到文件。第二种方式就是利用CPU的一个时间片来完成日志信息的打印。

注意：程序只能对新建状态的线程调用start()方法，不要对处于**非新建状态**的线程调用start() 方法，这都会引发IllegalThreadStateException异常。

#### 2.3.被阻塞状态（BLOCKED） ####

线程处于**等待**监视器**锁**而被阻塞的状态。有一个线程获取了锁未释放，其他线程也来获取，但发现获取不到锁也进入了被阻塞状态。

被阻塞状态只存在于多线程并发访问下，区别于后面两种因线程自己进入”等待“而导致的阻塞。

**进入状态**

*  进入synchronized 代码块/方法
 *  未获取到锁

**退出状态**

*  获取到监视器锁

#### 2.4.等待唤醒状态（WAITING） ####

整个流程是这样的：线程在某个对象的同步方法中先获取到对象锁；在执行wait方法时，该线程将释放对象锁，并且该线程被放入到这个对象的等待队列；等待另一个线程获取到同一个对象的锁，然后通过notify() 或 notifyAll() 方法唤醒对象等待队列中的线程。

从整个流程可以知道

> wait (),notify () 和 notifyAll () 方法需要在线程获取到锁的情况下才可以继续执行，所以这三个方法都需要放在同步代码块/方法中执行，否则报异常：java.lang.IllegalMonitorStateException。
> 
> 在同步代码块中，线程进入WAITING 状态时，锁会被释放，不会导致该线程阻塞。反过来想下，如果锁没释放，那其他线程就没办法获取锁，也就没办法唤醒它。

**进入状态**

*  object.wait()
 *  thread.join()
 *  LockSupport.park()

**退出状态**

*  object.notify()
 *  object.notifyall()
 *  LockSupport.unpark()

#### 2.5.计时等待状态（TIMED\_WAITING） ####

一般是计时结束就会自动唤醒线程继续执行后面的程序，对于Object.wait(long) 方法还可以主动通知唤醒。

注意：Thread类下的sleep() 方法可以放在任意地方执行；而wait(long) 方法和wait() 方法一样，需要放在同步代码块/方法中执行，否则报异常：java.lang.IllegalMonitorStateException。

**进入状态**

*  Thread.sleep(long)
 *  Object.wait(long)
 *  Thread.join(long)
 *  LockSupport.parkNanos(long)
 *  LockSupport.parkNanos(Object blocker, long nanos)
 *  LockSupport.parkUntil(long)
 *  LockSupport.parkUntil(Object blocker, long deadline)

注：blocker 参数为负责此线程驻留的同步对象。

**退出状态**

*  计时结束
 *  LockSupport.unpark(Thread)
 *  object.notify()
 *  object.notifyall()

#### 2.6.终止（TERMINATED） ####

线程执行结束

*  run()/call() 执行完成
 *  stop()线程
 *  错误或异常>>意外死亡

stop() 方法已弃用。

### 3.查看线程的6种状态 ###

通过一个简单的例子来查看线程出现的6种状态。

**案例**

public class Demo3 {
        
        private static Object object ="obj";
        
        public static void main(String[] args) throws InterruptedException {
        
    
            Thread thread0 = new Thread(() -> {
        
                try {
        
                    // 被阻塞状态（BLOCKED）
                    synchronized (object){
        
                        System.out.println("thread0 进入：等待唤醒状态（WAITING）");
                        object.wait();
                        System.out.println("thread0 被解除完成：等待唤醒状态（WAITING）");
                    }
                    System.out.println("thread0 "+Thread.currentThread().getState());
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            // 新创建状态（NEW）
            System.out.println(thread0.getName()+"："+thread0.getState());
    
            Thread thread1 = new Thread(() -> {
        
                try {
        
                    System.out.println("thread1 进入：计时等待状态（TIMED_WAITING）");
                    Thread.sleep(2);
                    System.out.println("thread1 出来：计时等待状态（TIMED_WAITING）");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                // 被阻塞状态（BLOCKED）
                synchronized (object){
        
                    System.out.println("thread1 解除：等待唤醒状态（WAITING）");
                    object.notify();
                    System.out.println("thread1 解除完成：等待唤醒状态（WAITING）");
                }
                System.out.println("thread1 "+Thread.currentThread().getState());
            });
            // 新创建状态（NEW）
            System.out.println(thread1.getName()+"："+thread1.getState());
    
            printState(thread0);
            printState(thread1);
    
            // 可运行状态（RUNNABLE）
            thread0.start();
            // 可运行状态（RUNNABLE）
            thread1.start();
    
        }
        
        
        // 使用独立线程来打印线程状态
        private static void printState(Thread thread) {
        
            new Thread(()->{
        
                while (true){
        
                    System.out.println(thread.getName()+"："+thread.getState());
                    if (thread.getState().equals(Thread.State.TERMINATED)){
        
                        System.out.println(thread.getName()+"："+thread.getState());
                        break;
                    }
                }
            }).start();
        }
    }

执行结果：简化后的输出结果

> Thread-0：NEW
> 
> Thread-1：NEW
> 
> Thread-0：RUNNABLE
> 
> Thread-1：RUNNABLE
> 
> thread0 进入：等待唤醒状态（WAITING）
> 
> Thread-1：BLOCKED
> 
> thread1 进入：计时等待状态（TIMED\_WAITING）
> 
> Thread-0：BLOCKED
> 
> Thread-0：WAITING
> 
> ……
> 
> Thread-0：WAITING
> 
> Thread-1：BLOCKED
> 
> Thread-1：TIMED\_WAITING
> 
> ……
> 
> Thread-1：TIMED\_WAITING
> 
> Thread-1：BLOCKED
> 
> ……
> 
> Thread-1：BLOCKED
> 
> Thread-0：WAITING
> 
> ……
> 
> Thread-0：WAITING
> 
> thread1 出来：计时等待状态（TIMED\_WAITING）
> 
> Thread-0：WAITING
> 
> Thread-1：BLOCKED
> 
> thread1 解除：等待唤醒状态（WAITING）
> 
> Thread-1：BLOCKED
> 
> Thread-0：WAITING
> 
> Thread-0：BLOCKED
> 
> thread1 解除完成：等待唤醒状态（WAITING）
> 
> Thread-1：BLOCKED
> 
> thread1 RUNNABLE
> 
> Thread-0：BLOCKED
> 
> Thread-1：TERMINATED
> 
> thread0 被解除完成：等待唤醒状态（WAITING）
> 
> Thread-0：BLOCKED
> 
> thread0 RUNNABLE
> 
> Thread-0：TERMINATED

![image][image 1]

最终的执行结果如图。

注意：因为案例中使用了独立线程来打印不同线程的状态，会出现状态打印稍微延迟的情况。

![image][image 2]

[自己编写平滑加权轮询算法，实现反向代理集群服务的平滑分配][Link 1]

[Java实现平滑加权轮询算法--降权和提权][Java_--]

[Java实现负载均衡算法--轮询和加权轮询][Java_-- 1]

[Java往期文章][Java]

[Java全栈学习路线、学习资源和面试题一条龙][Java 1]

[我心里优秀架构师是怎样的？][Link 2]

[免费下载经典编程书籍][Link 3]

更多优质文章，请关注WX公众号：Java全栈布道师

[image]: https://img-blog.csdnimg.cn/img_convert/d10d423b1735933f89a06f78f886701d.png
[image 1]: https://img-blog.csdnimg.cn/img_convert/b5542c6c1c6362ffaa2d8c959efeec5a.png
[image 2]: https://img-blog.csdnimg.cn/img_convert/0fa534d384f6e56de5d77af048d3585a.gif
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247485469&idx=1&sn=d81920b2ce30a1d675c95aa881627bd6&chksm=ec62c880db154196d1f37129cb9dc30f107814fa2da2f130f08a207da814fd25eba54ac3c18a&scene=21#wechat_redirect
[Java_--]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247485441&idx=1&sn=db09c8d233c743b3a4bdf7f4d2766b81&chksm=ec62c89cdb15418acf590bbe316a3e9cc9420959eac0d57858a5afb825cc45d8c20bafd2e765&scene=21#wechat_redirect
[Java_-- 1]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247485432&idx=1&sn=81347615fdec6a4e7e2bb2ae74d85f1b&chksm=ec62c765db154e7348c1b34ebeed1e0ec006c68cfbeda17f1321d4e318b155258982d093b898&scene=21#wechat_redirect
[Java]: https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzI5NDM5NDM1NA==&action=getalbum&album_id=2209403024081485826#wechat_redirect
[Java 1]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247485015&idx=1&sn=862bc2b379726b89cdb396ec0d325cc0&chksm=ec62c6cadb154fdc533111a253d72001534ab92de317cbde5c1c9f575548500bc734c3028484&scene=21#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247484980&idx=1&sn=cae79359673b411222f6108e8104e37a&chksm=ec62c6a9db154fbf1a7660547631dbc1ea3c764e1ccf30d223dab897dd7397aa730f3db56bf4&scene=21#wechat_redirect
[Link 3]: http://mp.weixin.qq.com/s?__biz=MzI5NDM5NDM1NA==&mid=2247485128&idx=1&sn=7ede1feed6c28f3b598095fe2e076a8b&chksm=ec62c655db154f43baea9eb87c9f1b8993adee277eb9e499036795411f788c75f87f8d8b6070&scene=21#wechat_redirect