文章目录

• • 1.状态的基本认识
  • 2.观察线程的所有状态
  • 3.线程状态和状态转移
  • 4.多线程的意义

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 的核心都满载了，这个时候启动更多的线程也没什么作用）