【JavaEE初阶】线程的状态和转移

今天药忘吃喽~ 2024-04-17 10:40 79阅读 0赞

#### 文章目录 ####

*  ?线程的状态
 *  ?观察线程的所有状态
 *  ?线程状态和状态转移的意义
 *  ?观察线程的状态和转移
 *   *  ?观察 1:
     *  ?观察 2:
     *  ?观察-3:
 *  ⭕总结

## ?线程的状态 ##

## ?观察线程的所有状态 ##

线程的状态是一个枚举类型 Thread.State,我们可以通过以下代码进行查看

public class ThreadState {
        
        public static void main(String[] args) {
        
            for (Thread.State state : Thread.State.values()) {
        
                System.out.println(state);
            }
        }
    }

结果如下：  
![在这里插入图片描述][5c4dc52ced75490cbe84cbbc440cfbed.png]  
每种状态的含义说明：

1、***NEW***

实现 Runnable 接口和继承 Thread 可以得到一个线程类，new 一个实例出来，线程就进入了初始状态。

***可以理解为安排了工作, 还未开始行动***

2、***RUNNABLE***

分为就绪状态 和 运行中状态

就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。

调用线程的 start() 方法，此线程进入就绪状态。

当前线程 sleep() 方法结束，其他线程 join() 结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。

当前线程时间片用完了，调用当前线程的 yield() 方法，当前线程进入就绪状态。

锁池里的线程拿到对象锁后，进入就绪状态。

运行中状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

***可以理解为可工作的. 又可以分成正在工作中和即将开始工作.***

3、***BLOCKED***

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态

***可以理解为排队等着其他事情***

4、WAITING:

处于这种状态的线程不会被分配 CPU 执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

***可以理解为排队等着其他事情***

5、***TIMED\_WAITING***

处于这种状态的线程不会被分配 CPU 执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

***可以理解为排队等着其他事情***

6、***TERMINATED***

当线程的 run() 方法完成时，或者主线程的 main() 方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦终止了，就不能复生

***可以理解为工作完成了***

## ?线程状态和状态转移的意义 ##

状态转移图如下：

![在这里插入图片描述][ae8d88f4dd084b4fae6be7cebaad0a7f.png]  
大家不要被这个状态转移图吓到，我们重点是要理解状态的意义以及各个状态的具体意思

接下来我们看个例子  
![在这里插入图片描述][7cb6c733b4724e5897ae58f01cfad138.png]  
还是我们之前的例子：

刚把李四、王五找来，还是给他们在安排任务，没让他们行动起来，就是 NEW 状态；

当李四、王五开始去窗口排队，等待服务，就进入到 RUNNABLE 状态。该状态并不表示已经被银行工作人员开始接待，排在队伍中也是属于该状态，即可被服务的状态，是否开始服务，则看调度器的调度;

当李四、王五因为一些事情需要去忙，例如需要填写信息、回家取证件、发呆一会等等时，进入BLOCKED 、 WATING 、 TIMED\_WAITING 状态，至于这些状态的细分，我们以后再详解；

如果李四、王五已经忙完，为 TERMINATED 状态。

所以，之前我们学过的 isAlive() 方法，可以认为是处于不是 NEW 和 TERMINATED 的状态都是活着的

## ?观察线程的状态和转移 ##

### ?观察 1: ###

关注 NEW 、 RUNNABLE 、 TERMINATED 状态的转换

*  使用 isAlive 方法判定线程的存活状

代码如下：

public class ThreadStateTransfer {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                for (int i = 0; i < 10; i++) {
        
                }
            }, "李四");
            System.out.println(t.getName() + ": " + t.getState());
            t.start();
            while (t.isAlive()) {
        
                System.out.println(t.getName() + ": " + t.getState());
            }
            System.out.println(t.getName() + ": " + t.getState());
        }
    }

运行结果如下：  
![在这里插入图片描述][aa544c5b11ed4c7b931ac98df2ad9347.png]

### ?观察 2: ###

关注 WAITING 、 BLOCKED 、 TIMED\_WAITING 状态的转换

public class TestMain {
        
        public static void main(String[] args) {
        
            final Object object = new Object();
            Thread t1 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (object) {
        
                        while (true) {
        
                            try {
        
                                //object.wait();
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
        
                                e.printStackTrace();}
                        }
                    }
                }
            }, "t1");
            t1.start();
            Thread t2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (object) {
        
                        System.out.println("hehe");
                    }
                }
            }, "t2");
            t2.start();
        }
    }

运行程序后，我们使用 jconsole 可以看到 t1 的状态是 TIMED\_WAITING ![在这里插入图片描述][1554fbc59d764e1e80baad894b67582c.png]  
t2 的状态是 BLOCKED

![在这里插入图片描述][e3e39aa019b740ff8068b814fbf8747e.png]  
修改上面的代码, 把 t1 中的 sleep 换成 wait

public class TestMain {
        
        public static void main(String[] args) {
        
            final Object object = new Object();
            Thread t1 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (object) {
        
                        while (true) {
        
                            try {
        
                                object.wait();
                                //Thread.sleep(1000);
                            } catch (InterruptedException e) {
        
                                e.printStackTrace();}
                        }
                    }
                }
            }, "t1");
            t1.start();
            Thread t2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (object) {
        
                        System.out.println("hehe");
                    }
                }
            }, "t2");
            t2.start();
        }
    }

使用 jconsole 可以看到 t1 的状态是 WAITING  
![在这里插入图片描述][4d1206eceeff4d4bb650c8a7bb99411e.png]

这里好多知识点博主还没有讲到，这里只是为了让大家看清楚状态转换的过程，设计的代码与概念，博主后面会一一介绍

结论:

*  BLOCKED 表示等待获取锁, WAITING 和 TIMED\_WAITING 表示等待其他线程发来通知.
 *  TIMED\_WAITING 线程在等待唤醒，但设置了时限; WAITING 线程在无限等待唤醒

### ?观察-3: ###

yield() 大公无私，让出 CPU

public class Main {
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    while (true) {
        
                        System.out.println("张三");
                        //先注释掉, 再放开
                        //Thread.yield();
                    }
                }
            }, "t1");
            t1.start();
            Thread t2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    while (true) {
        
                        System.out.println("李四");
                    }
                }
            }, "t2");
            t2.start();
        }
    }

我们运行之后可以看到:

1.  不使用 yield 的时候, 张三李四大概五五开
2.  使用 yield 时, 张三的数量远远少于李四

注意：yield 不改变线程的状态, 但是会重新去排队。相当于yield可以让别人插队，但依旧处于就绪态排队

## ⭕总结 ##

关于《【JavaEE初阶】 线程的状态和转移》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！

[5c4dc52ced75490cbe84cbbc440cfbed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/8f9920a8c28d4946a6cbefcf3912a89c.png
[ae8d88f4dd084b4fae6be7cebaad0a7f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/225bfecc8e944ae79194847a1127b72f.png
[7cb6c733b4724e5897ae58f01cfad138.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/c72044e2979a4f67972c35c9ad3e652f.png
[aa544c5b11ed4c7b931ac98df2ad9347.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/bcd680d56e6d44a188e590ae9489ea70.png
[1554fbc59d764e1e80baad894b67582c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/aebd466668d14b9ea629bdd1394750cb.png
[e3e39aa019b740ff8068b814fbf8747e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/03efcf5252964922879b4f7c67ce1dd9.png
[4d1206eceeff4d4bb650c8a7bb99411e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/e1c7a8dff37e41cc9b44bf1052bf6b19.png