线程的状态 - JavaEE

最新推荐文章于 2024-06-13 08:37:22 发布

玖汐」

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量102

点赞数

分类专栏： JavaEE 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/YeZh1Yong_Cr/article/details/128516842

版权

JavaEE 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

一、线程有哪些状态

状态也是线程的属性之一，能够描述当前线程调度的情况。线程的状态是一个枚举类型Thread.State，我们可以通过如下代码看到线程的所有状态：

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

运行结果：

解释一下各种状态：

1. NEW

创建了Thread对象，但是还没调用start，没有启动线程，内核里还没有创建对应PCB

2. TERMINATED

表示内核中的PCB已经执行完毕了，但是Thread对象还在

3. RUNNABLE

表示线程是可运行的：（1）线程正在CPU上执行；（2）线程在就绪队列里，可以随时上CPU执行

4. WAITING

5. TIMED_WAITING

6. BLOCKED

以上三个都表示线程正在排队等待其他事情，表示线程PCB正在阻塞队列中，但是阻塞原因是不同的。

二、线程状态及转换

在线程调度中线程状态的转换关系可以由下图所示，以中间NEW、RUNNABLE、TERMINATED为主线：

1. 线程对象t存在的意义

当线程处在TERMINATED状态时，会存在内核中PCB没了，但是代码中的t还在这样的情况。实际上一旦内核里的线程PCB消亡了，此时代码中的t对象就没什么用了。之所以存在，是迫不得已的，因为Java中的对象的生命周期，自有其规则，这个生命周期和系统内核里的线程并非完全一致。内核里的线程释放的时候，无法保证Java代码中t对象也立即释放，所以t可能还会存在。

注意：一个线程只能start一次！上述t在TERMINATED之后也是不能重新start一次，主要原因是这是编程圈里约定俗成的规则：一个变量/一个对象，只有一个用途（不是强制的）。一个变量/对象，可以干多件事情但这样做不好，可能会让代码混乱。t线程对象如果TERMINATED之后还有重新启用的机会，程序员就不好判定这里的t到底是一个有效的还是无效的。如果明确TERMINATED就是终结状态，就没有重新start的机会了，此时程序员就可以心安理得的放弃t，同时后续任何代码中（t里的线程）都可以视为是不太科学的操作。

我们通过代码来体会一下线程的状态：

public class ThreadDemo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                // 这个循环体啥都不干, 也不 sleep

            }
        });

        // 启动之前, 获取 t 的状态, 就是 NEW 状态.
        System.out.println("start 之前: " + t.getState());

        t.start();

            System.out.println("t 执行中的状态: " + t.getState());
        t.join();

        // 线程执行完毕之后, 就是 TERMINATED 状态
        System.out.println("t 结束之后: " + t.getState());
    }
}

运行结果：

其中t在执行中的状态为RUNNABLE，其原因是当前线程run里面，没写任何sleep之类的方法。当加了sleep之后的打印状态中，具体看到的是RUNNABLE还是TIMED_WAITING就不一定了，这取决于当前t线程是运行到哪个环节：

public class ThreadDemo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                // 这个循环体啥都不干, 也不 sleep

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 启动之前, 获取 t 的状态, 就是 NEW 状态.
        System.out.println("start 之前: " + t.getState());

        t.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("t 执行中的状态: " + t.getState());
        }
        t.join();

        // 线程执行完毕之后, 就是 TERMINATED 状态
        System.out.println("t 结束之后: " + t.getState());
    }
}

运行结果：

通过对t执行中的状态循环获取，就能看见t的交替状态了，那么当前获取到的状态到底是什么，完全取决于系统里的调度操作，获取状态这一瞬间，t线程所处的状态是正在执行还是sleep，不确定。

2. 多线程的意义

我们写的程序分成CPU密集和IO密集类，其中CPU包含大量的加减乘除等算术运算，而IO类涉及到读写文件，读写控制台，读写网络等，我们主要研究CPU密集类的程序，比如说现在有一个运算量很大的任务，我们来看看多线程和单线程的区别：

public class ThreadDemo12 {
    public static void main(String[] args) {
        // 假设当前有两个变量, 需要把两个变量各自自增 1000w 次. (典型的 CPU 密集型的场景)
        // 可以一个线程, 先针对 a 自增, 然后再针对 b 自增
        // 还可以两个线程, 分别对 a 和 b 自增.
        serial();
        concurrency();
    }

    // 串行执行, 一个线程完成
    public static void serial() {
        long beg = System.currentTimeMillis();
        long a = 0;
        for (long i = 0; i < 100_0000_0000L; i++) {
            a++;
        }
        long b = 0;
        for (long i = 0; i < 100_0000_0000L; i++) {
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println("执行时间: " + (end - beg) + " ms");
    }

    public static void concurrency() {
        Thread t1 = new Thread(() -> {
            long a = 0;
            for(long i = 0; i < 100_0000_0000L; i++) {
                a++;
            }
        });
        Thread t2 = new Thread(() -> {
            long b = 0;
            for(long i = 0; i < 100_0000_0000L; i++) {
                b++;
            }
        });
        long beg = System.currentTimeMillis();
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("并发执行时间: " + (end - beg) + " ms");
    }
}

运行结果：

可以看到比起单个线程执行，两个线程并发执行的时间明显缩短了，但是为什么时间不是正好缩短一半呢？主要是多线程使用CPU资源并不一定是在多个CPU上执行的，实际上上述例子的两个线程t1和t2在执行过程中，会经历很多次的调度。这些次的调度，有些是并发执行的（在一个核心上），有些是并行执行的（正好在两个核心上）。另一方面，线程调度自身也是有时间消耗的。

多线程在这种CPU密集型的任务中，有非常大的作用，可以充分利用CPU的多核资源，从而加快程序的运行效率。但是要注意的是使用多线程，就一定能提高效率。首先得考虑CPU是否是多核的，其次考虑当前核心是否空闲（如果CPU这些核心都已经满载了，这个时候启动更多的线程也没啥用）