概述
-
今天主要看看以下几部分内容
- 线程状态
- 线程终止
- 内存屏障和 CPU 缓存
- 线程通信
- 线程封闭
1. 线程状态
1. 6个状态
- 网上的答案各种各样,有5个,有6个,还有7个的,大家直接从官方源码,从以下枚举中查看线程的状态就可以了。
java.lang.Thread.State
- NEW: 尚未启动的线程的线程状态。
- RUNNABLE: 可运行线程的线程状态,等待CPU调度。
- BLOCKED: 线程阻塞等待监视器锁定的线程状态。处于 synchronized 同步代码块或方法中被阻塞。
- WAITING: 等待线程的线程状态。下列不带超时的方式:
Object.wait
、Thread.join
、LockSupport.park
- TIMED_WAITING: 具有指定等待时间的等待线程的线程状态。下列带超时的方式:
Thread.sleep
、Object.wait
、Thread.join
、LockSupport.parkNanos
、LockSupport.parkUntil
- TERMINATED: 终止线程的线程状态。线程正常完成执行或者出现异常。
2. 线程状态切换
3. 线程状态切换示例代码
1. 新建 > 运行 > 终止
System.out.println("################### 第一种状态切换 - 新建 > 运行 > 终止 ###################");
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread1 当前状态:" + Thread.currentThread().getState().toString());
System.out.println("thread1 执行了");
}
});
System.out.println("没调用 start 方法,thread1 当前状态: " + thread1.getState().toString());
thread1.start();
Thread.sleep(2000L); // 等待 thread1 执行结束,再看状态
System.out.println("等待两秒,再看 thread1 当前状态: " + thread1.getState().toString());
// thread1.start(); 当线程终止,再次调用 start 方法时,会抛出 IllegalThreadStateException 异常。
2. 新建 > 运行 > 等待 > 运行 > 终止(sleep方式)
System.out.println("################### 第二种状态切换 - 新建 > 运行 > 等待 > 运行 > 终止(sleep方式) ###################");
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread2 当前状态: " + Thread.currentThread().getState().toString());
System.out.println("thread2 执行了");
}
});
System.out.println("没调用 start 方法,thread2 当前状态: " + thread2.getState().toString());
thread2.start();
System.out.println("调用 start 方法,thread2 当前状态: " + thread2.getState().toString());
Thread.sleep(200L); // 等待 200 毫秒,再看状态
System.out.println("等待 200 毫秒,再看 thread2 当前状态: " + thread2.getState().toString());
Thread.sleep(3000L); // 再等 3 秒,让 thread2 执行完毕,再看状态
System.out.println("等待 3 秒,再看 thread2 当前状态: " + thread2.getState().toString());
3. 新建 > 运行 > 阻塞 > 运行 > 终止
System.out.println("################### 第三种状态切换 - 新建 > 运行 > 阻塞 > 运行 > 终止 ###################");
Thread thread3 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (Demo2.class) {
System.out.println("thread3 当前状态: " + Thread.currentThread().getState().toString());
System.out.println("thread3 执行了");
}
}
});
synchronized (Demo2.class) {
System.out.println("没调用 start 方法,thread3 当前状态: " + thread3.getState().toString());
thread3.start();
System.out.println("调用 start 方法,thread3 当前状态: " + thread3.getState().toString());
Thread.sleep(200L); // 等待 200 毫秒,再看状态
System.out.println("等待 200 毫秒,再看 thread3 当前状态: " + thread3.getState().toString());
}
Thread.sleep(3000L);
2. 线程终止
1. 不正确的线程终止 - stop
- stop: 终止线程,并且清除监控器锁的信息,但是可能导致线程安全问题,JDK 不建议使用。
- destory: JDK 未实现该方法。
2. 正确的线程终止 - interrupt
-
如果目标线程在调用 Object class 的 wait()、wait(long) 或 wait(long,int)方法、join()、join(long,int) 或 sleep(long,int) 方法时被阻塞,那么 interrupt 会生效,则线程的中断状态将会被清除,抛出 InterruptedException 异常。
-
如果目标线程是被 I/O 或者 NIO 中的 Channel 所阻塞,同样,I/O 操作会被中断或者返回异常值。达到终止线程的目的。
-
如果以上条件都不满足,则会设置此线程的中断状态。
3. 正确的线程终止 - 标志位
- 代码逻辑中,增加一个判断,用来控制线程执行的终止。
4. 代码演示
1. stop 和 interrupt
package com.study.hc.thread.chapter1.thread;
public class StopThread extends Thread {
private int i = 0, j = 0;
@Override
public void run() {
synchronized (this) {
// 增加同步锁,确保线程安全
++i;
try {
// 休眠 10 秒,模拟耗时操作
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
++j;
}
}
/** 打印 i 和 j */
public void print() {
System.out.println("i=" + i + " j=" + j);
}
}
package com.study.hc.thread.chapter1.thread;
/**
* 示例3 - 线程 stop 强制性终止,破坏线程安全的示例
*/
public class Demo3 {
public static void main(String[] args) throws InterruptedException {
StopThread thread = new StopThread();
thread.start();
// 休眠 1 秒,确保变量 i 变量自增成功
Thread.sleep(1000);
// 中止线程
// thread.stop();
thread.interrupt(); // 正确终止
while (thread.isAlive()) {
// 确保线程已经终止
}
// 输出结束
thread.print();
}
}
2. 添加标志位
package com.study.hc.thread.chapter1.thread;
public class Demo4 {
public volatile static boolean flag = true;
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
try {
while (flag) {
System.out.println("运行中");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
// 3 秒之后,将状态标志改为 false,代表不继续执行
Thread.sleep(3000);
flag = false;
System.out.println("程序运行结束");
}
}
3. 内存屏障和 CPU 缓存
1. CPU 性能优化手段 - 缓存
- 为了提高程序运行的性能,现代 CPU 在很多方面对程序进行了优化。
- 例如: CPU 高速缓存。尽可能地避免处理器访问主内存的时间开销,处理器大多会利用缓存(cache)以提高性能。
三级缓存
-
L1 Cache (一级缓存)是 CPU 第一层高速缓存,分为数据缓存和指令缓存。一般服务器 CPU 的 L1 缓存的容量通常在 32-4096KB。
-
L2 由于 L1 级高速缓存容量的限制,为了再次提高 CPU 的运算速度,在 CPU 外部放置一高速存储器,即二级缓存。
-
L3 现在的都是内置的。而它的实际作用是,L3 缓存的应用可以进一步降低内存延迟,同时提升大数据量计算时处理器的性能。具有较大 L3 缓存的处理器提供更有效的文件系统缓存行为及较短消息和处理器队列长度。一般是多核共享一个 L3 缓存。
CPU 在读取数据时,先在 L1 中寻找,再从 L2 寻找,再从 L3 寻找,然后是内存,再后是外存储器。
缓存同步协议
-
多 CPU 读取同样的数据进行缓存,进行不同运算之后,最终写入主内存以那个 CPU 为准?
-
在这种高速缓存回写的场景下,有一个缓存一致性协议多数 CPU 厂商对它进行了实现。
-
MESI 协议,它规定每条缓存有个状态位,同时定义了下面四种状态:
- 修改态(Modified) - 此 cache 行已被修改过(脏行),内容已不同于主存,为此 cache 专有。
- 专有态(Exclusive) - 此 cache 行内容同于主存,但不出现于其他 cache 中。
- 共享态(Shared) - 此 cache 行内容同于主存,也出现于其他 cache 中。
- 无效态(Invalid) - 此 cache 内容无效(空行)。
-
多处理器时,单个 CPU 对缓存中数据进行了改动,需要通知给其他 CPU。
-
也就意味着,CPU 处理要控制自己的读写操作,还要监听其他 CPU 发出的通知,从而保证最终一致性。
2. CPU 性能优化手段 - 运行时指令重排
-
指令重排的场景:当 CPU 写缓存时发现缓存区块正被其他 CPU 占用,为了提高 CPU 处理性能,可能将后面的读缓存命令优先执行。
-
并非随便重排,需要遵守
as-if-serial
语义。 -
as-if-serial
语义的意思指:不管怎么重排序(编译器和处理器为了提高并行度),(单线程)程序的执行结果不能改变。编译器,runtime 和处理器都必须遵守as-if-serial
语义。 -
也就是说,编译器和处理器不会对存在数据依赖关系的操作做重排序。
3. 两个问题
-
CPU 高速缓存下有一个问题:缓存中的数据与主内容的数据并不是实时同步的,各 CPU(或 CPU 核心)间缓存的数据也不是实时同步的。在同一时间点,各 CPU 所看到同一内存地址的数据的值可能是不一致的。
-
CPU 执行指令重排序优化下有一个问题:虽然遵守了
as-if-serial
语义,单仅在单 CPU 自己执行的情况下能保证结果正确。多核多线程中,指令逻辑无法分辨因果关联,可能出现乱序执行,导致程序运行结果错误。
4. 内存屏障
- 处理器提供了两个内存屏障指令(Memory Barrier)用于解决上述两个问题。
1. 写内存屏障(Store Memory Barrier)
- 在指令后插入 Store Barrier,能让写入缓存中的最新数据更新写入主内存,让其他线程可见。
- 强制写入主内存,这种显示调用,CPU 就不会因为性能考虑而去对指令重排。
2. 读内存屏障(Load Memory Barrier)
- 在指令前插入 Load Barrier,可以让告诉缓存中的数据失效,强制重新从主内存加载数据。
- 强制读取主内存内容,让 CPU 缓存与主内存保持一致,避免了缓存存在的一致性问题。
4. 线程通信
1. 通信的方式
-
想要实现多个线程之间的协同,如:线程执行先后顺序、获取某个线程执行的结果等等。
-
涉及到线程之间相互通信,分为下面四类:
- 文件共享
- 网络共享
- 共享变量
- JDK 提供的线程协调 API
suspend/resume- wait/notify
- park/unpark
2. 文件共享
代码演示
public class Demo5 {
public static void main(String[] args) {
// 线程 1 - 写入数据
new Thread(() -> {
try {
while (true) {
Files.write(Paths.get("Demo5.log"),
("当前时间 " + System.currentTimeMillis()).getBytes());
Thread.sleep(1000);
}
} catch (Exception e) {
e.printStackTrace();
}
}).start();
// 线程 2 - 读取数据
new Thread(() -> {
try {
while (true) {
Thread.sleep(1000);
byte[] allBytes = Files.readAllBytes(Paths.get("Demo5.log"));
System.out.println(new String(allBytes));
}
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}
3. 变量共享
代码演示
public class Demo6 {
public static String content = "空";
public static void main(String[] args) {
// 线程 1 - 写入数据
new Thread(() -> {
try {
while (true) {
content = "当前时间: " + System.currentTimeMillis();
Thread.sleep(1000);
}
} catch (Exception e) {
e.printStackTrace();
}
}).start();
// 线程 2 - 读取数据
new Thread(() -> {
try {
while (true) {
Thread.sleep(1000);
System.out.println(content);
}
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}
4. JDK API
-
JDK 中对于需要多线程协作完成某一任务的场景,提供了对应的 API 支持。
-
多线程协作的典型场景是:生产者-消费者模型。(线程阻塞、线程唤醒)
示例
- 线程 1 去买包子,没有包子,则不再执行。线程 2 生产出包子,通知线程 1 继续执行。
1. 被弃用的 suspend 和 resume
-
调用 suspend 挂起目标线程,通过 resume 可以恢复线程执行。
-
代码示例
public void suspendResumeTest() throws InterruptedException { // 启动线程 Thread consumerThread = new Thread(() -> { if (baozidian == null) { System.out.println("1. 没包子,进入等待"); Thread.currentThread().suspend(); } System.out.println("2. 买到包子,回家"); }); consumerThread.start(); // 3 秒之后,生产一个包子 Thread.sleep(3000); baozidian = new Object(); consumerThread.resume(); System.out.println("3. 通知消费者"); }
-
被弃用的主要原因是:容易写出死锁的代码。所以使用
wait
/notify
和park
/unpark
机制对它进行替代。 -
死锁示例 - 1. 同步代码中使用
// suspend 挂起之后并不会释放锁,故此容易写出死锁代码 public void suspendResumeDeadLockTest() throws InterruptedException { // 启动线程 Thread consumerThread = new Thread(() -> { if (baozidian == null) { // 如果没有包子,则进入等待 System.out.println("1. 进入等待"); // 当前线程拿到锁,然后挂起 synchronized (this) { Thread.currentThread().suspend(); } } System.out.println("2. 买到包子,回家"); }); consumerThread.start(); // 3 秒之后,生产一个包子 Thread.sleep(3000); baozidian = new Object(); // 争取到锁以后,再恢复 consumerThread synchronized (this) { consumerThread.resume(); } System.out.println("3. 通知消费者"); }
-
死锁示例 - 2. suspend 比 resume 后执行
// 先执行 suspend,后执行 resume,反之则死锁 public void suspendResumeDeadLockTest2() throws InterruptedException { // 启动线程 Thread consumerThread = new Thread(() -> { if (baozidian == null) { System.out.println("1. 没包子,进入等待"); try { // 为这个线程加上一点延时 Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // 这里的挂起执行在 resume 之后 Thread.currentThread().suspend(); } System.out.println("2. 买到包子,回家"); }); consumerThread.start(); // 3 秒之后,生产一个包子 Thread.sleep(3000); baozidian = new Object(); consumerThread.resume(); System.out.println("3. 通知消费者"); consumerThread.join(); }
2. wait/notify 机制
-
这些方法只能由同一对象锁的持有者线程调用,也就是写在同步块里面,否则会抛出 IllegalMonitorStateException 异常。
-
wait 方法导致当前线程等待,加入该对象的等待集合中,并且放弃当前持有的对象锁。
-
notify/notifyAll 方法唤醒一个或所有正在等待这个对象所的线程。
-
注意:虽然 wait 会自动解锁,但是对顺序有要求,如果在 notify 被调用之后,才开始 wait 方法的调用,线程会永远处于 WAITING 状态。
-
死锁代码示例
// 会导致程序永久等待的 wait/notify public void waitNotifyDeadLockTest() throws InterruptedException { // 启动线程 new Thread(() -> { if (baozidian == null) { // 如果没有包子,则进入等待 try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (this) { try { System.out.println("1. 进入等待"); this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } System.out.println("2. 买到包子,回家"); }).start(); // 3 秒之后,产生一个包子 Thread.sleep(3000); baozidian = new Object(); synchronized (this) { this.notifyAll(); System.out.println("3. 通知消费者"); } }
3. park/unpark 机制
-
线程调用
park
则等待“许可”,unpark
方法为指定线程提供“许可(permit)”。 -
不要求
park
和unpark
方法的调用顺序。 -
多次调用
unpark
之后,再调用park
,线程会直接运行,但不会叠加。也就是说,连续多次调用park
方法,第一次会拿到“许可”直接运行,后续调用会进入等待。
// 正常的 park/unpark
public void parkUnparkTest() throws InterruptedException {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (baozidian == null) { // 如果没有包子,则进入等待
System.out.println("1. 进入等待");
LockSupport.park();
}
System.out.println("2. 买到包子,回家");
});
consumerThread.start();
// 3 秒之后,生产一个包子
Thread.sleep(3000);
baozidian = new Object();
LockSupport.unpark(consumerThread);
System.out.println("3. 通知消费者");
}
- 因 park/unpark 不会释放锁,所以同步代码块中会产生死锁。
// park/unpark 死锁
public void parkUnparkDeadLockTest() throws InterruptedException {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (baozidian == null) {
synchronized (this) {
System.out.println("1. 进入等待");
LockSupport.park();
}
}
System.out.println("2. 买到包子,回家");
});
consumerThread.start();
// 3 秒之后,生产一个包子
Thread.sleep(3000);
baozidian = new Object();
// 争取到锁以后,再恢复 consumerThread
synchronized (this) {
LockSupport.unpark(consumerThread);
}
System.out.println("3. 通知消费者");
}
4. 3种方法的总结
-
suspend/resume 对调用顺序有要求,也要开发自己注意锁的释放。这个被弃用的 API,容易死锁,也容易导致永久挂起。
-
wait/notify 要求在同步关键字里面使用,免去了死锁的困扰,但是一定要先调用 wait,再调用 notify,否则永久等待了。
-
park/unpark 没有顺序要求,但是 park 并不会释放,所以同步代码中使用要注意。
5. 伪唤醒
-
警告!之前代码中用 if 语句来判断,是否进入等待状态,是错误的!
-
官方建议应该在循环中判断等待条件,原因是处于等待状态的线程可能会收到错误警报和伪唤醒,如果不在循环中检查等待条件,程序就会在没有满足结束条件的情况下退出。
-
伪唤醒是指线程并非因为 notify、notifyall、unpark 等 api 调用而唤醒,是更底层原因导致的。
-
示例代码
// 启动线程 Thread consumerThread = new Thread(() -> { while (baozidian == null) { synchronized (this) { System.out.println("1. 进入等待"); LockSupport.park(); } } System.out.println("2. 买到包子,回家"); }); consumerThread.start();
5. 线程封闭
1. 概念
-
多线程访问共享可变数据时,涉及到线程间数据同步的问题。并不是所有时候,都要用到共享数据,所以线程封闭概念就提出来了。
-
数据都被封闭在各自的线程中,就不需要同步,这种通过将数据封闭在线程中而避免使用同步的技术称为线程封闭。
-
线程封闭具体的表现有:ThreadLocal、局部变量。
2. ThreadLocal
-
ThreadLocal 是 java 中一种特殊的变量。
-
它是一个线程级别变量,每个线程都有一个 ThreadLocal,就是每个线程都拥有自己独立的一个变量,竞争条件被彻底消除了,在开发模式下是绝对安全的变量。
-
用法:ThreadLocal<T> var = new ThreadLocal<T>();
-
会自动在每个线程上创建一个 T 的副本,副本之间彼此独立,互不影响。
-
可以用 ThreadLocal 存储一些参数,以便在线程中多个方法中使用,用来代替方法传参的做法。
package com.study.hc.thread.chapter1.thread;
/**
* 线程封闭示例
*/
public class Demo8 {
// ThreadLocal 变量,每个线程都有一个副本,互不干扰
public static ThreadLocal<String> value = new ThreadLocal<>();
public static void main(String[] args) throws InterruptedException {
new Demo8().threadLocalTest();
}
/**
* ThreadLocal 测试
*/
public void threadLocalTest() throws InterruptedException {
// ThreadLocal 线程封闭示例
value.set("这是主线程设置的 123"); // 主线程设置值
String v = value.get();
System.out.println("线程 1 执行之前,主线程取到的值:" + v);
new Thread(() -> {
String v2 = value.get();
System.out.println("线程 1 取到的值:" + v2);
// 设置 ThreadLocal
value.set("这是线程 1 设置的 456");
v2 = value.get();
System.out.println("重新设置之后,线程 1 取到的值:" + v2);
System.out.println("线程 1 执行结束");
}).start();
Thread.sleep(5000); // 等待所有线程执行结束
v = value.get();
System.out.println("线程 1 执行之后,主线程取到的值:" + v);
}
}
3. 栈封闭
- 局部变量的固有属性之一就是封闭在线程中。
- 它们位于执行线程的栈中,其他线程无法访问这个栈。