【多线程】线程状态

明天不吃。

已于 2024-06-26 07:33:21 修改

阅读量2k

点赞数 26

分类专栏：多线程文章标签： java 开发语言

于 2024-06-18 18:47:41 首次发布

本文链接：https://blog.csdn.net/m0_61814277/article/details/139334461

版权

多线程专栏收录该内容

8 篇文章 2 订阅

订阅专栏

🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈

在这里插入图片描述

文章目录

1. 枚举线程所有状态
2. 线程转移

1. 枚举线程所有状态

操作系统里的线程自身是有一个状态，在Java中，Thread是对系统线程的封装，把这里的状态又进一步细化~下面一起来看看线程的状态！
线程的状态是一个枚举类型Thread.State，通过下面代码枚举线程的所有状态

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

打印结果如下：
在这里插入图片描述
具体解释各线程状态含义：
【NEW】安排工作但还未开始行动，即系统中的线程还没有建出来，只是有个Thread对象
【RUNNABLE】可工作，可以分为正在工作中和即将开始工作，即就绪状态，分为两种：一是正在CPU上运行；二是准备好随时可以去CPU上运行
【BLOCKED】排队等着其它的事，具体表示等待锁出现的状态
【WAITING】排队等着其它的事，具体表示使用wait()方法出现的状态
【TIMED_WAITING】排队等着其它的事，具体表示指定时间等待，sleep()方法
【TERMINATED】工作完成，表示系统中的线程已经执行完毕，Thread对象仍在
通过示意图，以去银行办理业务为例，以便我们能够更好地了解~如下所示：
在这里插入图片描述
这个例子是，把张三找来给他安排任务，但目前没让他行动起来，则是NEW状态

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

当王五和李四等人突然有其它的事情需要忙，比如需要填写基本信息等，进入到TIMED_WAITING、BLOCKED、WAITING状态

如果他们忙完了则为TERMINATED状态

通过上图，我们可以看到：

1）TIMED_WAITING、BLOCKED、WAITING状态都表示排队等待
2）前面我们学习过isAlive()方法，判断线程是否存活，NEW和TERMINATED的状态为不存活，其余状态均为活着

下面通过代码具体来看看吧~
1）NEW 表示系统中的线程还没有建出来，只是有个Thread对象

public class ThreadDemo {
        public static void main(String[] args) {
            Thread t = new Thread(() -> {
                System.out.println("hi！");
            });

            // 在线程启动前 获取线程状态getState()----> NEW
            System.out.println(t.getState());
            t.start();
        }
}

运行结果如下图：
在这里插入图片描述
2）TERMINATED 表示系统中的线程已经执行完毕，Thread对象仍在

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("hi！");
        });

        // 在线程启动前 获取线程状态getState()----> NEW
        System.out.println(t.getState());
        t.start();

        // 线程已执行完 但Thread对象还在---->  TERMINATED
        // 为保证调用t.getState()的时候 线程已经执行完 所以先调用sleep让main线程休眠等待一段时间
        Thread.sleep(3000);
        System.out.println(t.getState());
    }
}

运行结果如下图：
在这里插入图片描述
3）RUNNABLE 表示可工作状态，可以分为正在工作中和即将开始工作，即就绪状态，分为两种：一是正在CPU上运行；二是准备好随时可以去CPU上运行，即一个“随叫随到”的状态

public class ThreadDemo {
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                while(true) {
                    //System.out.println("hi！");
                }
            });

            // 在线程启动前 获取线程状态getState()----> NEW
            System.out.println(t.getState());

            t.start();

            Thread.sleep(3000);
            // 此时调用t.getState()获取线程状态 线程仍正在执行 看上述代码 死循环 ----> RUNNABLE
            System.out.println(t.getState());
        }
}

运行结果如下图：
在这里插入图片描述
4）TIMED_WAITING 表示排队等着其它的事，具体表示指定时间等待，如正在休眠的sleep()方法，即线程正在“指定时间等待”
下述代码中， t 线程内是sleep()休眠，在最后一行代码查询 t 线程状态时，因为t线程正在休眠状态，所以状态为TIMED_WAITING

public class ThreadDemo {
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                while(true) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });

            // 在线程启动前 获取线程状态getState()----> NEW
            System.out.println(t.getState());

            t.start();

            Thread.sleep(5000);
            System.out.println(t.getState());
        }
}

运行结果如下图：
在这里插入图片描述
【为什么要理解线程状态？】
理解线程状态就是为了让我们能够更好的进行多线程代码调试!!!

2. 线程转移

2.1 示意图

【简化】一条主线，三条支线
在这里插入图片描述
详细补充如下图：

（图片来自:https://blog.csdn.net/pange1991）

2.2 观察 NEW 、 RUNNABLE 、 TERMINATED 状态的转换

使用 isAlive() 方法判定线程的存活状态
通过以下代码可以观察到线程在NEW、RUNNABLE和TERMINATED三个状态之间的转换:

public class ThreadStateTransfer {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
            }
        }, "我的线程名字叫线程t");
        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());;
    }
}

运行结果如下图：
在这里插入图片描述
【解释说明】
上述代码创建一个线程t，t 线程中的线程体中设置循环，执行 100次(设置为100次，为方便起见)，循环执行完毕后即线程终止，具体过程如下：
1）线程启动前，此时线程的状态为NEW，即线程还没有建出来，只是有个Thread对象
2）在线程的存活期间内，此时调用线程为RUNNABLE 的状态，即就绪状态

【回顾isAlive() 方法】
isAlive()该方法用于判定线程的存活状态，存活指的是线程已启动且尚未终止，当线程正在运行或着准备开始运行的时候，该方法就认为线程是“存活”的，并以true或false的形式返回

3）在线程终止后，此时线程的状态为TERMINATED，即线程已经执行完毕

2.3 观察 WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换

通过以下代码可以观察到线程在WAITING 、 BLOCKED 、 TIMED_WAITING 三个状态之间的转换:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        final Object object = new Object();
 
        // 创建线程t1
        Thread t1 = new Thread(() -> {
            synchronized (object) {
                while (true) {
                    try {
                        Thread.sleep(1000);
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
               }
            }
       }, "t1");
 
        // 启动t1
        t1.start();
 
        // 创建线程t2
        Thread t2 = new Thread(() -> {
            synchronized (object) {
                System.out.println("xixi");
           }
       }, "t2");
 
        //启动t2
        t2.start();
    }
}

使用jconsole工具可以观察，如下图：
在这里插入图片描述
【解释说明】
创建 t1 线程，给 t1 线程加锁，t1 线程内不断进行休眠sleep()操作
创建 t2 线程，给 t2 线程加锁，t2 线程内打印xixi
通过jconsole工具概观察得到，t1 的状态为 TIME_WAITING，t2 的状态为 BLOCKED
因为启动 t1 线程时，t1 获得了锁，且进入sleep()循环，此时 t1 线程一直在进行“指定时间等待”的操作，因此状态为 TIME_WAITING，启动 t2 线程时，此时 t1 线程还未释放锁，t2 只能等待获取锁，t1 一直不释放锁，t2 就只能一直等待，因此 t2 的状态是BLOCKED
(锁的相关知识在后期内容讲解，敬请期待一下叭~)
但是可以看到打印台是空白的，什么东西都没有打印
在这里插入图片描述
如果将 t1 线程中的sleep改成wait，t1 的状态就变为了WAITING，如下：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        final Object object = new Object();

        // 创建线程t1
        Thread t1 = new Thread(() -> {
            synchronized (object) {
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");

        // 启动t1
        t1.start();

        // 创建线程t2
        Thread t2 = new Thread(() -> {
            synchronized (object) {
                System.out.println("xixi");
            }
        }, "t2");

        //启动t2
        t2.start();
    }
}

使用 jconsole 可以看到 t1 的状态是 WAITING，如下图：
在这里插入图片描述
打印台信息如下：

【解释说明】
t1 线程中调用的 object.wait() 方法

在Java中，线程必须持有对象的锁才能调用 wait() 方法！
当线程调用wait() 方法时，它会释放当前持有的锁，并将自己挂起，直到被其他线程唤醒，一旦线程调用了wait()方法并释放了锁，其他线程即可以获取该对象的锁并继续执行同步块中的代码，当该线程被唤醒即notify时，它会重新尝试获取对象的锁并恢复执行。但在其它线程未释放锁之前该线程仍然会被阻塞！一旦它获得了对象的锁，它才可以继续执行同步块中的代码

所以在上述代码中，当 t1 调用 object.wait() 方法时，它会释放 object 对象的锁，即在 t1 等待时，其他线程比如如这里的 t2 线程，可以获得该对象的锁并执行同步块中的代码，打印出xixi，但只有当 t1 线程被唤醒并重新获得对象的锁时，它才会继续执行同步块中的代码。t1一直不被唤醒，就一直处于无限等待的状态，此时查看 t1 的线程状态，为WAITING
【结论】
1）BLOCKED 与 WAITING 、TIMED_WAITING的区别
BLOCKED 表示等待获取锁，WAITING 和 TIMED_WAITING 表示等待其他线程发来通知
2） TIMED_WAITING 与 WAITING 的区别
TIMED_WAITING 线程在等待唤醒，但是设置了时限；而WAITING 线程在无限地等待唤醒

2.4 yield()让出CPU

yield() 不改变线程的状态，但会让线程重新去排队，下面具体介绍yield()方法：
1）yield() 方法介绍
yield() 方法是Java中的一个静态方法，它属于 Thread类，用于使当前线程让出CPU资源，让其他具有相同或更高优先级的线程运行
2）yield() 方法作用
调用 yield()方法并不会释放锁或者阻塞当前线程，它只是暂停当前线程的执行，并允许其他线程先获得执行，当当前线程被重新调度时，它将继续执行，但并不能保证它会立即被调度!!!
3）yield() 方法的调用
调用 yield() 方法并不能保证其他线程会获得执行，因为调度器可以选择忽略 yield() 方法的调用。过度使用 yield() 方法可能会导致性能问题，频繁的调用 yield() 方法可能会导致线程频繁地切换，从而降低系统的性能
4）yield() 方法的使用场景
通常情况下，使用 yield()方法是为了避免长时间的占用CPU资源。

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        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 时，打印“柚子”的数量远远少于“球球”
【原因】
每次执行到 t1线程中的 Thread.yield() 方法时，都会使 t1 线程暂时让出CPU资源，重新去排队，让 t2 线程先获得执行，即 t2 线程被执行到的次数就大大增加了
💛💛💛本期内容回顾💛💛💛
在这里插入图片描述
✨✨✨本期内容到此结束啦~下期内容将介绍线程安全，多线程带来的风险！（期待ing）

明天不吃。

关注

26
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
【多线程】线程状态

本期内容主要是介绍线程所有状态，以及线程转移，观察 NEW 、 RUNNABLE 、 TERMINATED 状态的转换与观察 WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换，最后详细介绍yield()方法。
复制链接

扫一扫