java EE初阶 — 线程的状态

1.状态的基本认识

1. NEW 创建了 Thread 对象，但是还没调用 start（内核里还没有创建对应的PCB）
2. TERMINATED 表示内核中的 PCB 已经执行完毕了，但是 Thread 对象还在。
3. RUNNABLE 可运行的。（叫做RUNNALBE，而不是RUNNING）
   又可以分为：

• 正在 CPU 上执行。
• 在就绪队列里，随时可以去CPU上执行。

4. WAITING
5. TIMED_WAITING
6. BLOCKED
   4、5、6都是阻塞（都是表示线程PCB正在阻塞队列中），只不过是不同原因的阻塞。

2.观察线程的所有状态

package thread;

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

线程的状态是一个枚举类型 Thread.State。

3.线程状态和状态转移

线程的状态转换图

NEW 和 TERMINATED 状态的演示：

package thread;

public class ThreadDemo13 {
    public static void main(String[] args) throws InterruptedException{
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10000000; i++) {

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

        thread.start();
        thread.join();

        //执行结束之后，就是 TERMINATED状态
        System.out.println("thread 结束之后：" + thread.getState());
    }
}

一旦内核里的线程 PCB 消亡了，此时代码中的 thread 对象也就没什么用了。

之所以存在，是因为java中的对象的生命周期自有其规则。
这个生命周期和系统内核里的线程并非完全一致。
内核的线程释放的时候，无法保证java代码中的thread对象也立即释放。

因此，势必会存在，内核的PCB没了，但是代码中的thread还在的情况。
此时就需要通过特定的状态来把thread对象标识成 “无效”。


RUNNABLE 和 TIMED_WAITING状态的演示：

package thread;

public class ThreadDemo13 {
    public static void main(String[] args) throws InterruptedException{
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10000000; i++) {

            }
        });
        //启动之前获取thread的状态，就是NEW状态
        System.out.println("start之前:" + thread.getState());
        
        thread.start();
        System.out.println("执行中的状态：" + thread.getState());

        thread.join();

        //执行结束之后，就是 TERMINATED状态
        System.out.println("thread 结束之后：" + thread.getState());
    }
}

之所以可以看到 RUNNABLE 主要就是因为当前线程run里面，没写任何的sleep之类的方法。

当然也可以看到TIMED_WAITING。

设置一个循环打印执行中的状态。

package thread;

public class ThreadDemo13 {
    public static void main(String[] args) throws InterruptedException{
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10000000; i++) {
                
            }
        });
        //启动之前获取thread的状态，就是NEW状态
        System.out.println("start之前:" + thread.getState());

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

        thread.join();

        //执行结束之后，就是 TERMINATED状态
        System.out.println("thread 结束之后：" + thread.getState());
    }
}

package thread;

public class ThreadDemo13 {
    public static void main(String[] args) throws InterruptedException{
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        //启动之前获取thread的状态，就是NEW状态
        System.out.println("start之前:" + thread.getState());

        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("执行中的状态：" + thread.getState());
        }

        thread.join();

        //执行结束之后，就是 TERMINATED状态
        System.out.println("thread 结束之后：" + thread.getState());
    }
}

通过这里的循环获取，就可以看到这里的交替状态了。
当前获取的状态，到底是什么，完全取决于系统里的调度操作。
获取这一状态的瞬间，到底 thread 线程是处在什么样的状态。（sleep、还是正在执行）

当前只演示这四个状态，剩下的 WAITING 和 BLOCKED 后面再演示。

4.多线程的意义

写一个代码，来感受一下单线程和多线程的执行速度的差别。

程序分成 CPU 密集和 IO 密集。

• CPU 密集，包含了大量的加减乘除等算术运算。
• IO密集，涉及到了读写文件，读写控制台，读写网络。

写一个代码来执行一个算量很大的任务，来比较一下单线程和多线程的执行速度差异。

public class ThreadDemo14 {
    public static void main(String[] args) {
        //现在有两个变量，把两个变量自增加100亿次（典型的CPU密集型场景
        //可以一个线程，先针对a自增，在针对b自增
        //还可以两个线程分别对a和b自增
        serial();
        concurrency();
    }

    //串行执行，一个线程完成
    public static void serial() {
        //为了衡量带没带的速度。加上一个计时的操作。
        //curretTimeMillis 获取当前系统的 ms 级时间戳
        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");
    }
}

main 线程先调用t1.start，启动 t1 开始计算 t1 的同时，
main再调用 t2.start，启动 t2 的同时，t1 仍然在继续计算。
同时，main 线程就进入 t1.join，此时，main阻塞等待了，t1 和 t2 还是要继续执行。

等到t1执行结束了，main线程从t1.join返回，再进入 t2.join。
再来等待，等到 t2 执行完了，main 从 t2.join 返回，继续执行计时操作。

main 调用的是 t1.join 就是 main 来等待 t1
如果是 t2 调用 t1.join，就是 t2 等待 t1。

join 只是限制了 main 最后结束，并不知道 t1 和 t2 谁先结束。


对于上面的代码执行3次后取中间值。

两个线程就像是两个人同时执行一个任务，按说速度应该是单线程的一半才对。
可是观察结果会发现，三次多线程的速度都不是单线程的一半。

原因：

t1 和 t2 才执行的过程中，会经历许多调度。
这些次调度，有些是并发执行的（在一个核心上），有些事并行执行的（在两个核心上）
另一方面，线程调度自身也是有时间消耗的。
虽然缩短的不是百分之五十，但是仍然是很明显的，仍然很有意义。


多线程在这种 CPU 密集型的任务中，有非常大的作用，可以充分利用 CPU 的多核资源，
从而加快程序的运行效率。

不是说使用多线程就一定可以提高效率。
还要考虑：

• 是否是多核（现在的CPU基本上都是多核了）
• 当前核心是否是空闲的。（如果 CPU 的核心都满载了，这个时候启动更多的线程也没什么作用）