文章目录
线程通信的方式
要想实现多个线程之间的协同,如:线程执行先后顺序、获取某个线程执行的结果等等。涉及到线程之间相互通信,分为下面四类：
- 文件共享
- 网络共享
- 共享变量
- jdk提供的线程协调API:
细分为：suspend/resume、wait/notify、park/unpark
文件共享
文件共享的意思就是一个线程把数据写入一个文件（例如a.txt）中,而另外一个线程从这个文件中读取数据的过程,例如下图:
网络共享
下次讲网络编程的时候会详解。
变量共享
就是一个线程把数据写入内存,而另一个线程去读取该数据的过程。
线程协作-JDK API
这组API可以使用一个非常经典的使用场景：生产者 - 消费者模型来展现:
即线程1去买包子,没有包子,则不再执行。线程-2生产出包子,通知线程1继续执行（也可以用购买火车票来模拟）:
被弃用的suspend和resume
调用suspend挂起目标线程,通过resume可以恢复线程执行。下面用suspend和resume来演示一下买包子的过程:
public static void main(String[] args) throws InterruptedException {
//启动线程
Thread consumerThread = new Thread(() -> {
if (baozidian == null) {
System.out.println("1、还没有包子，进入等待");
Thread.currentThread().suspend();
}
System.out.println("2、买到包子,回家");
baozidian=null;
});
consumerThread.start();
//停止3秒,模拟做包子的过程
Thread.sleep(3000L);
baozidian=new Object();
//唤醒线程
consumerThread.resume();
System.out.println("3、通知消费者");
}
看上去也没什么问题,但是为什么启用呢?因为很容易出现死锁的情况?再来看一段代码。
//启动线程
Thread consumerThread = new Thread(() -> {
if (baozidian == null) {
System.out.println("1、还没有包子，进入等待");
synchronized(this) {
Thread.currentThread().suspend();
}
}
System.out.println("2、买到包子,回家");
baozidian=null;
});
consumerThread.start();
//停止3秒,模拟做包子的过程
Thread.sleep(3000L);
baozidian=new Object();
//唤醒线程
synchronized (this) {
consumerThread.resume();
}
System.out.println("3、通知消费者");
注意:此处不是在main方法中执行,因为静态方法无法使用this作为锁,一般都是用反射类来做锁。而两个this都是同一个实例,因为lambada表达式中并不会将其视为匿名内部类中的方法,而是该类的方法
死锁成因
从上面的代码可以明显的看到两个锁对象是同一个,但是当线程suspend之前已经取得了锁对象,而在resume之前还没释放该对象,所以想要释放this锁对象就必须执行完suspend的代码块,但是想要执行完该代码块必须resume,可是想要resume就必须释放this锁,三者是一个连环,但是一个都执行不了,造成了死锁。
wait/notify机制
这两个方法只能由同一对象锁的持有者线程调用,也就是说写在同步代码块里,否则的话就抛出IllegalMonitorStateException异常。
wait方法导致当前线程等待,加入该对象的等待集合中,并且放弃当前持有的对象锁。notify/notifyAll方法唤醒一个或所有正在等待这个对象锁的线程。
注意：wait虽然会自动解锁,但是对顺序有要求,如果在notify被调用后才开始wait的话,线程将永远处于WAITING状态。
详细代码
public void waitNotifyTest() throws InterruptedException {
Thread comsumerThread = new Thread(() -> {
if(baozidian==null){
System.out.println("1、没有包子,开始等待");
synchronized (this) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("2、包子已经做好,买走");
}
}
});
comsumerThread.start();
//三秒后生产出一个包子
Thread.sleep(3000l);
synchronized (this) {
this.notify();
}
System.out.println("3、通知消费者");
}
上述代码就是wait和notify的使用了,注意锁是什么就是什么。这样做可以避免线程同步带来的死锁问题了,但是还是有可能会出现线程被永久挂起的情况,如:
public void waitNotifyDeadLockTest() throws Exception {
// 启动线程
new Thread(() -> {
if (baozidian == null) { // 如果没包子，则进入等待
try {
Thread.sleep(5000L);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
synchronized (this) {
try {
System.out.println("1、进入等待");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("2、买到包子，回家");
}).start();
// 3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian = new Object();
synchronized (this) {
this.notifyAll();
System.out.println("3、通知消费者");
}
}
这段代码很明显就是会导致notifyAll之后才wait,就永久挂起了。
park/unpark机制
线程如果调用park则表示等待“许可”,unpark方法为指定线程提供“许可(permit)”。
不要求park和unpark方法的调用顺序。
代码示例
public void parkUnparkTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
while (baozidian == null) { // 如果没包子，则进入等待
System.out.println("1、进入等待");
LockSupport.park();
}
System.out.println("2、买到包子，回家");
});
consumerThread.start();
// 3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian = new Object();
LockSupport.unpark(consumerThread);
System.out.println("3、通知消费者");
}
死锁演示
public void parkUnparkDeadLockTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (baozidian == null) { // 如果没包子，则进入等待
System.out.println("1、进入等待");
// 当前线程拿到锁，然后挂起
synchronized (this) {
LockSupport.park();
}
}
System.out.println("2、买到包子，回家");
});
consumerThread.start();
// 3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian = new Object();
// 争取到锁以后，再恢复consumerThread
synchronized (this) {
LockSupport.unpark(consumerThread);
}
System.out.println("3、通知消费者");
}
伪唤醒
其实我们之前代码中用if语句来做判断是否进入等待状态是有问题的,这是一种错误的写法。官方建议应该在循环中检查等待条件,因为处于等待状态的线程可能会被伪唤醒,如果不在循环中检查等待条件,程序就会在没有满足结束条件的情况下退出。
伪唤醒是指线程并非因为notify、notifyall、unpark等api调用而唤醒,是更底层的原因。
总结
每一种API都有导致线程的使用中出现问题,需要足够了解才能避免出现死锁和永久挂起现象。
