文章目录

• 线程与进程
• 并行与并发
• 进程与线程应用
• • 应用之异步调用
  • 应用之提高效率
• 线程的创建
• • 方法一：通过继承Thread类创建
  • 方法二：使用Runnable配合Thread
  • 方法三：使用FutureTask与Thread结合创建
• 查看进程和线程的方法
• 线程运行的原理
• • 栈与栈帧
  • 线程上下文切换（Thread Context Switch）
• 线程中的常见方法
• • start 与 run
  • sleep、yield与线程优先级
  • sleep的应用：防止CPU占用过高
  • join
  • 同步的应用
  • interrupt方法详解
  • interrupt方法的应用——两阶段终止模式
  • 使用interrupt打断park线程
  • 不推荐使用的方法
• 主线程和守护线程
• 线程的状态
• • 五种状态
  • 六种状态

线程与进程

进程

• 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。
• 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
• 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器 等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

线程

• 一个进程之内可以分为一到多个线程。
• 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行 。
• Java 中，线程作为小调度单位，进程作为资源分配的小单位。 在 windows 中进程是不活动的，只是作为线程的容器

两者对比

• 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集

• 进程拥有共享的资源，如内存空间等，供其内部的线程共享

• 进程间通信较为复杂

  • 同一台计算机的进程通信称为 IPC（Inter-process communication）
  • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP

• 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量

• 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

上下文切换后面会提到

并行与并发

在单核 cpu 下，线程实际还是串行执行的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是同时运行的 。

一般会将这种线程轮流使用 CPU 的做法称为并发（concurrent）

多核 cpu下，每个 核（core） 都可以调度运行线程，这时候线程可以是并行的。

事实上，大多数时候并行和并发是同时存在的，因为线程数大于核心数的情况经常发生，所以这个时候就还是需要任务调度器使用并发的那套处理方法。

引用 Rob Pike 的一段描述：
并发（concurrent）是同一时间应对（dealing with）多件事情的能力 。
并行（parallel）是同一时间动手做（doing）多件事情的能力。

例子：

• 家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发
• 雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行
• 家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一 个人用锅时，另一个人就得等待）

进程与线程应用

应用之异步调用

以调用方的角度讲：

• 如果需要等待结果返回才能继续运行的话就是同步
• 如果不需要等待就是异步

设计
多线程可以使方法的执行变成异步的，比如说读取磁盘文件时，假设读取操作花费了5秒，如果没有线程的调度机制，这么cpu只能等5秒，啥都不能做。

结论

• 比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程
• tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
• ui 程序中，开线程进行其他操作，避免阻塞 ui 线程

应用之提高效率

充分利用多核 cpu 的优势，提高运行效率。想象下面的场景，执行 3 个计算，最后将计算结果汇总。

计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms

• 如果是串行执行，那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms

• 但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个 线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms

注意：

需要在多核 cpu 才能提高效率，单核仍然时是轮流执行

结论：

1. 单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu ，不至于一个线程总占用 cpu，别的线程没法干活
2. 多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的
   • 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任 务都能拆分（参考后文的【阿姆达尔定律】）
   • 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义
3. IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一 直等待 IO 结束，没能充分利用线程。所以才有后面的【非阻塞 IO】和【异步 IO】优化。

线程的创建

方法一：通过继承Thread类创建

//创建线程对象
// 构造方法的参数是给线程指定名字，，推荐给线程起个名字
Thread t1 = new Thread("t1") {@Override// run 方法内实现了要执行的任务public void run() {log.debug("hello");}
};
//启动线程
t1.start();

注意：

• 使用继承方式的好处是，在run（）方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread（）方法；
• 不好的地方是Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。
• 另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码

方法二：使用Runnable配合Thread

把【线程】和【任务】（要执行的代码）分开，

• Thread 代表线程，
• Runnable 可运行的任务（线程要执行的代码）

public class Test2 {public static void main(String[] args) {//创建线程任务Runnable r = new Runnable() {@Overridepublic void run() {System.out.println("Runnable running");}};// 参数1 是任务对象; 参数2 是线程名字，推荐Thread t = new Thread(r, "t2");//启动线程t.start();}
}

Java 8 以后可以使用 lambda 精简代码；

当一个接口带有@FunctionalInterface注解时，是可以使用lambda来简化操作的

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

方法三：使用FutureTask与Thread结合创建

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

public class Test3 {public static void main(String[] args) throws ExecutionException, InterruptedException {//需要传入一个Callable对象FutureTask task = new FutureTask(new Callable() {@Overridepublic Integer call() throws Exception {System.out.println("线程执行!");Thread.sleep(1000);return 100;}});Thread r1 = new Thread(task, "t2");r1.start();//获取线程中方法执行后的返回结果System.out.println(task.get());}
}

或者

// 创建任务对象
FutureTask task3 = new FutureTask<>(() -> {log.debug("hello");return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

注意：

• FutureTask实现了RunnableFuture接口，而RunnableFuture接口继承了Runnable和Future接口

• FutureTask内置了一个Callable对象，初始化方法将指定的Callable赋给这个对象。

• FutureTask实现了Runnable接口，并重写了Run方法，在Run方法中调用了Callable中的call方法，并将返回值赋值给outcome变量

• get方法就是取出outcome的值。

• Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
  

  • Future提供了三种功能：
    • 判断任务是否完成；
    • 能够中断任务；
    • 能够获取任务执行结果。

• Callable与Runnable接口相似，但是Callable接口中的call方法可以有返回值。

总结：
使用继承方式的好处是方便传参，你可以在子类里面添加成员变量，通过set方法设置参数或者通过构造函数进行传递，而如果使用Runnable方式，则只能使用主线程里面被声明为final的变量。不好的地方是Java不支持多继承，如果继承了Thread类，那么子类不能再继承其他类，而Runable则没有这个限制。前两种方式都没办法拿到任务的返回结果，但是Futuretask方式可以

查看进程和线程的方法

windows

• 任务管理器可以查看进程和线程数，也可以用来杀死进程
• tasklist 查看进程
  • tasklist | findstr (查找关键字)
• taskkill 杀死进程
  • taskkill /F(彻底杀死）/PID(进程PID)

Linux

• ps -fe 查看所有进程
• ps -fT -p 查看某个进程（PID）的所有线程
• kill 杀死进程 top 按大写 H 切换是否显示线程
• top -H -p 查看某个进程（PID）的所有线程

Java

• jps 命令查看所有 Java 进程
• jstack 查看某个 Java 进程（PID）的所有线程状态
• jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

jconsole 远程监控配置

• 需要以如下方式运行你的 java 类

  java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote -
  Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 -
  Dcom.sun.management.jmxremote.authenticate=是否认证 java类
  

• 关闭防火墙，允许端口

• 修改 /etc/hosts 文件将 127.0.0.1 映射至主机名

如果要认证访问，还需要做如下步骤

• 复制 jmxremote.password 文件
• 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
• 连接时填入 controlRole（用户名），R&D（密码）

线程运行的原理

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟 机就会为其分配一块栈内存。

• 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法，也就是栈顶的那个方法

我们来看一个例子：

public class TestFrames {public static void main(String[] args) {method1(10);}private static void method1(int x) {int y = x + 1;Object m = method2();System.out.println(m);}private static Object method2() {Object n = new Object();return n;}
}

注意；

• 方法区在jvm启动的时候被创建，其也是逻辑上的栈结构，但是里面放的是对用的jvm认识的字节码指令集，跟图中的方法区并不是完全一样
• 方法区是所有Java虚拟机线程的共享区，但是栈区域是每个线程独立的

线程上下文切换（Thread Context Switch）

线程上下文切换：因为某一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

有如下四个比较常见的线程上下文发生切换的原因：

• 线程的 cpu 时间片用完
• 垃圾回收
• 有更高优先级的线程需要运行
• 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念 就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

• 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
• Context Switch 频繁发生会影响性能

线程中的常见方法

start 与 run

我们知道start用来启动线程，而run表示线程启动之后要执行的代码。那么我们能不能直接调用run方法来执行多线程任务呢？

调用 run

public static void main(String[] args) {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug(Thread.currentThread().getName());FileReader.read(Constants.MP4_FULL_PATH);}};t1.run();log.debug("do other things ...");
}

输出

19:39:14 [main] c.TestStart - main
19:39:14 [main] c.FileReader - read [1.mp4] start ...
19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
19:39:18 [main] c.TestStart - do other things ...

程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的

调用start

将上述代码的 t1.run() 改为

t1.start();

输出

19:41:30 [main] c.TestStart - do other things ...
19:41:30 [t1] c.TestStart - t1
19:41:30 [t1] c.FileReader - read [1.mp4] start ...
19:41:35 [t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms

程序在 t1 线程运行， FileReader.read() 方法调用是异步的

小结

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程

• 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

  public static void main(String[] args) {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug("running...");}};System.out.println(t1.getState());t1.start();System.out.println(t1.getState());
  }
  

  可以看见，start方法创建了一个新线程，将线程从就绪状态切换为Runnable

  NEW
  RUNNABLE
  03:45:12.255 c.Test5 [t1] - running...
  

sleep、yield与线程优先级

sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程(也就是叫醒)，这时 sleep 方法会抛出 InterruptedException

   public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug("enter sleep...");try {Thread.sleep(2000);} catch (InterruptedException e) {log.debug("wake up...");e.printStackTrace();}}};t1.start();Thread.sleep(1000);log.debug("interrupt...");t1.interrupt();
   }
   

   输出结果：

   03:47:18.141 c.Test7 [t1] - enter sleep...
   03:47:19.132 c.Test7 [main] - interrupt...
   03:47:19.132 c.Test7 [t1] - wake up...
   java.lang.InterruptedException: sleep interruptedat java.lang.Thread.sleep(Native Method)at cn.itcast.test.Test7$1.run(Test7.java:14)
   

3. 睡眠结束后的线程未必会立刻得到执行

4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性 。其底层还是sleep方法。

   @Slf4j(topic = "c.Test8")
   public class Test8 {public static void main(String[] args) throws InterruptedException {log.debug("enter");TimeUnit.SECONDS.sleep(1);log.debug("end");
   //        Thread.sleep(1000);}
   }
   

5. 在循环访问锁的过程中，可以加入sleep让线程阻塞时间，防止大量占用cpu资源。

yield

1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
2. 具体的实现依赖于操作系统的任务调度器

Runnable 就绪状态和Timed Waiting 状态都是为了将CPU的使用权让出去，但是他们的区别在于：Runnable状态还是有可能会分到时间片，而Timed Waiting状态在设置的休眠时间之内是不会得到时间片的。

线程优先级

• 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
• 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

测试优先级和yield

@Slf4j(topic = "c.TestYield")
public class TestYield {public static void main(String[] args) {Runnable task1 = () -> {int count = 0;for (;;) {System.out.println("---->1 " + count++);}};Runnable task2 = () -> {int count = 0;for (;;) {
//                Thread.yield();System.out.println("              ---->2 " + count++);}};Thread t1 = new Thread(task1, "t1");Thread t2 = new Thread(task2, "t2");t1.setPriority(Thread.MIN_PRIORITY);t2.setPriority(Thread.MAX_PRIORITY);t1.start();t2.start();}
}

测试结果：

#优先级
---->1 283500
---->2 374389
#yield
---->1 119199
---->2 101074

可以看出，线程优先级和yield会对线程获取cpu时间片产生一定影响，但不会影响太大。

sleep的应用：防止CPU占用过高

while true的无限循环在做一些服务器开发的时候会用到。比如说我们编写一个服务端的程序，那他就需要服务器的多线程不断运行来处理请求返回响应。

sleep 实现

在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权 给其他程序

while(true) {try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}
}

使用前：

使用后：

• 可以用 wait 或 条件变量达到类似的效果
• 不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
• sleep 适用于无需锁同步的场景

wait 实现

synchronized(锁对象) {while(条件不满足) { try {锁对象.wait();} catch(InterruptedException e) {e.printStackTrace();}}// do sth...
}

条件变量实现

lock.lock();
try {while(条件不满足) {try {条件变量.await();} catch (InterruptedException e) {e.printStackTrace();}}// do sth...
} finally {lock.unlock();
}

join

为什么需要 join

下面的代码执行，打印 r 是什么？

static int r = 0;
public static void main(String[] args) throws InterruptedException {test1();
}
private static void test1() throws InterruptedException {log.debug("开始");Thread t1 = new Thread(() -> {log.debug("开始");sleep(1);log.debug("结束");r = 10;});t1.start();log.debug("结果为:{}", r);log.debug("结束");
}

分析

• 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
• 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法

• 用 sleep 行不行？为什么？
  • 如果用sleep也可以但是你不知道线程t1要运行多长时间，设置长了影响效率，设置短了t1可能还没执行完
• 用 join，在 t1.start() 之后加上t1.join即可

同步的应用

以调用方角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步
• 不需要等待结果返回，就能继续运行就是异步

等待多个结果

问，下面代码 cost 大约多少秒？

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {test2();
}
private static void test2() throws InterruptedException {Thread t1 = new Thread(() -> {sleep(1);r1 = 10;});Thread t2 = new Thread(() -> {sleep(2);r2 = 20;});long start = System.currentTimeMillis();t1.start();t2.start();t1.join();t2.join();long end = System.currentTimeMillis();log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}  

分析如下

• 第一个 join：等待 t1 时, t2 并没有停止, 而在运行
• 第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

也就是说花费了两秒

如果颠倒两个 join 呢？

最终都是输出

20:45:43.239 [main] c.TestJoin - r1: 10 r2: 20 cost: 2005

interrupt方法详解

用于打断阻塞(sleep wait join…)的线程。 处于阻塞状态的线程，CPU不会给其分配时间片。

• 如果一个线程在在运行中被打断，打断标记会被置为true。
• 如果是打断因sleep wait join方法而被阻塞的线程，会将打断标记置为false

//用于查看打断标记，返回值为boolean类型
t1.isInterrupted();

我们查看打断标记有两种方法，isInterrupted不会清除打断标记。但是interrupted会清除打断标记，也就是说如果我们当前打断标记为True使用interrupted查询返回True，随后打断标记为false，也就是被清除。

正常运行的线程在被打断后，不会停止，会继续执行。如果要让线程在被打断后停下来，需要使用打断标记来判断。

while(true) {if(Thread.currentThread().isInterrupted()) {break;}
}

interrupt方法的应用——两阶段终止模式

在一个线程T1中如何优雅的终止线程T2，也就是让T2有终止前的准备工作？

注意：
如下两种方法是错误的：

• 使用线程对象的stop方法停止线程
  • stop方法会真正杀死线程，如果这是线程锁住了共享资源，那么当他被杀死后就再也没有机会释放锁，其他线程将永远无法获取锁
• 使用System.exit(int)方法停止线程
  • 目的仅是停止一个线程，但这种做法会让整个程序都停止

这里我们就可以使用interrupt方法来实现两阶段终止模式。

比如现在我们在做一个程序可以帮助我们监控电脑的运行状况，如果我们想要把他暂停应该怎么做？

从这个流程图中我们可以看到如果我们在非睡眠的情况下被打断了，那么打断标记就是true，我们根据这个标记让线程处理后事。如果是在睡眠的时候被打断，那么会抛出一个异常，我们捕获这个异常之后，再去设置打断标记，当新的一轮循环检测标记，也会让线程料理后事，然后才结束循环。

我们有如下两种代码实现：

利用 isInterrupted

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

class TPTInterrupt {private Thread thread;public void start(){thread = new Thread(() -> {while(true) {Thread current = Thread.currentThread();if(current.isInterrupted()) {log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("将结果保存");} catch (InterruptedException e) {current.interrupt();}// 执行监控操作 }},"监控线程");thread.start();}public void stop() {thread.interrupt();}
}

调用

TPTInterrupt t = new TPTInterrupt();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

结果

11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:43.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:44.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:45.413 c.TestTwoPhaseTermination [main] - stop 
11:49:45.413 c.TwoPhaseTermination [监控线程] - 料理后事

利用停止标记

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
class TPTVolatile {private Thread thread;private volatile boolean stop = false;public void start(){thread = new Thread(() -> {while(true) {Thread current = Thread.currentThread();if(stop) {log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("将结果保存");} catch (InterruptedException e) {}// 执行监控操作}},"监控线程");thread.start();}public void stop() {stop = true;thread.interrupt();}
}

调用

TPTVolatile t = new TPTVolatile();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

结果

11:54:52.003 c.TPTVolatile [监控线程] - 将结果保存
11:54:53.006 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.007 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.502 c.TestTwoPhaseTermination [main] - stop 
11:54:54.502 c.TPTVolatile [监控线程] - 料理后事

使用interrupt打断park线程

打断 park 线程, 不会清空打断状态

private static void test3() throws InterruptedException {Thread t1 = new Thread(() -> {log.debug("park...");LockSupport.park();log.debug("unpark...");log.debug("打断状态：{}", Thread.currentThread().isInterrupted());}, "t1");t1.start();sleep(0.5);t1.interrupt();
}

LockSupport.park()方法也会让当前线程停下来。而t1.interrupt()会进行打断，让线程继续进行。

输出

21:11:52.795 [t1] c.TestInterrupt - park... 
21:11:53.295 [t1] c.TestInterrupt - unpark... 
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true 

如果打断标记已经是 true, 则 park 会失效

private static void test4() {Thread t1 = new Thread(() -> {for (int i = 0; i < 5; i++) {log.debug("park...");LockSupport.park();log.debug("打断状态：{}", Thread.currentThread().isInterrupted());}});t1.start();sleep(1);t1.interrupt();
}

输出

21:13:48.783 [Thread-0] c.TestInterrupt - park... 
21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.812 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 

提示

可以使用 Thread.interrupted() 清除打断状态，让park方法恢复其作用。

不推荐使用的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

主线程和守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

例:

log.debug("开始运行...");
Thread t1 = new Thread(() -> {log.debug("开始运行...");sleep(2);log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

输出：

08:26:38.123 [main] c.TestDaemon - 开始运行... 
08:26:38.213 [daemon] c.TestDaemon - 开始运行... 
08:26:39.215 [main] c.TestDaemon - 运行结束... 

注意

• 垃圾回收器线程就是一种守护线程
• Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

线程的状态

五种状态

这是从 操作系统 层面来描述的

• 【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联（例如线程调用了start方法）

• 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行

• 【运行状态】指获取了 CPU 时间片运行中的状态

  • 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换

• 【阻塞状态】

  • 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入 【阻塞状态】
  • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
  • 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

• 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

六种状态

这是从 Java API 层面来描述的

根据 Thread.State 枚举，分为六种状态

• NEW 线程刚被创建，但是还没有调用 start() 方法
• RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的 【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为 是可运行）
• BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，如sleep就为TIMED_WAITING， join为WAITING状态。后面会在状态转换一节详述。
• TERMINATED 当线程代码运行结束

我们可以用代码演示一下这六种状态：

@Slf4j(topic = "c.TestState")
public class TestState {public static void main(String[] args) throws IOException {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug("running...");}};Thread t2 = new Thread("t2") {@Overridepublic void run() {while(true) { // runnable}}};t2.start();Thread t3 = new Thread("t3") {@Overridepublic void run() {log.debug("running...");}};t3.start();Thread t4 = new Thread("t4") {@Overridepublic void run() {synchronized (TestState.class) {try {Thread.sleep(1000000); // timed_waiting} catch (InterruptedException e) {e.printStackTrace();}}}};t4.start();Thread t5 = new Thread("t5") {@Overridepublic void run() {try {t2.join(); // waiting} catch (InterruptedException e) {e.printStackTrace();}}};t5.start();Thread t6 = new Thread("t6") {@Overridepublic void run() {synchronized (TestState.class) { // blockedtry {Thread.sleep(1000000);} catch (InterruptedException e) {e.printStackTrace();}}}};t6.start();try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}log.debug("t1 state {}", t1.getState());log.debug("t2 state {}", t2.getState());log.debug("t3 state {}", t3.getState());log.debug("t4 state {}", t4.getState());log.debug("t5 state {}", t5.getState());log.debug("t6 state {}", t6.getState());System.in.read();}
}

结果：