线程通信
线程通信指的是多个线程在运行的期间，相互之间的数据交互协作。
1.通信方式
实现多个线程直接的协作，涉及到的通信方式主要四类。
1）文件共享
2）网络共享
3）共享变量
4）JDK提供的线程协调API
1.文件共享
线程A写文件，线程B读取文件达到线程协作。
2.网络共享
线程A发送数据，线程B接受数据达到线程协作。
3.共享变量
利用内存的公共区域，共享变量。线程A修改变量，线程B读取变量达到线程协作。
以上3种方式都是比较触及的，我们主要链接JDK给我提供的API
2.线程协作 JDK API
生产者消费者模型是线程协作的典型场景(线程阻塞、线程唤醒)，我们以一个示例去理解
示例：线程A提车，没有车，则不执行。线程B有车了，通知线程A继续执行
2.1 suspend/resume
suspend挂起线程，resume恢复线程执行。这两个API是Thread提供的。
示例：
public static Object benz = null;
public void suspendResumeTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (benz == null) { // 如果没奔驰，则进入等待
System.out.println("1、进入等待");
Thread.currentThread().suspend();
}
System.out.println("2、提到车，回家");
});
consumerThread.start();
// 3秒之后，拉来一辆奔驰
Thread.sleep(3000L);
benz = new Object();
consumerThread.resume();
System.out.println("3、通知消费者");
}
suspend/resume虽然是Thread提供的，因为很容易写出死锁的代码。 所以被弃用了。
死锁示例1：在写同步代码的时候容易出现：suspend在挂起之后并不会释放锁
public void suspendResumeDeadLockTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (benz == null) { // 如果没奔驰，则进入等待
System.out.println("1、进入等待");
// 当前线程拿到锁，然后挂起
synchronized (this) {
Thread.currentThread().suspend();
}
}
System.out.println("2、提到车，回家");
});
consumerThread.start();
// 3秒之后，拉来一辆奔驰
Thread.sleep(3000L);
benz = new Object();
// 争取到锁以后，再恢复consumerThread
synchronized (this) {
consumerThread.resume();
}
System.out.println("3、通知消费者");
}
这种情况下消费者如果拿到锁，消费者就挂起了，生产者要通知消费者必须要抢到锁，但是因为消费者抢到锁之后挂起，并没有释放锁，生产者是抢不到锁，这就死锁了。
死锁示例2: API调用顺序：suspend在resume后执行死锁
public void suspendResumeDeadLockTest2() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (benz == null) {
System.out.println("1、没奔驰，进入等待");
try { // 为这个线程加上一点延时
Thread.sleep(5000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 这里的挂起执行在resume后面
Thread.currentThread().suspend();
}
System.out.println("2、提到车，回家");
});
consumerThread.start();
// 3秒之后，拉来一辆奔驰
Thread.sleep(3000L);
benz = new Object();
consumerThread.resume();
System.out.println("3、通知消费者");
consumerThread.join();
}
这种情况下suspend在resume后执行，线程恢复不了执行，死锁了。
2.2 wait/notify
这一对API只能由统一对象锁的持有者调用，也就是写在同步代码块里面，否则抛异常。
wait使当前线程等待，加入该对象的等待池，并释放锁。
notify/notifyAll唤醒一个或所有正在等待这个对象的线程
因为必须用在同步代码块里面， wait/notify针对锁的问题不存在了。但是顺序需要注意。
示例：
public void waitNotifyTest() throws Exception {
// 启动线程
new Thread(() -> {
if (benz == null) { // 如果没奔驰，则进入等待
synchronized (this) {
try {
System.out.println("1、进入等待");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("2、提到车，回家");
}).start();
// 3秒之后，拉来一辆奔驰
Thread.sleep(3000L);
benz = new Object();
synchronized (this) {
this.notifyAll();
System.out.println("3、通知消费者");
}
}
注意：虽然wait会释放锁，但是对顺序有要求，如果wait在notify之调用，线程就永远处于WAITING状态了。
死锁示例：
public void waitNotifyDeadLockTest() throws Exception {
// 启动线程
new Thread(() -> {
if (benz == 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);
benz = new Object();
synchronized (this) {
this.notifyAll();
System.out.println("3、通知消费者");
}
}
这种情况下wait在notify后执行，线程收不到通知，死锁了。
2.3 park/unpark
park等待许可，unpark提供许可令牌,让线程继续执行，park/unpark没有顺序要求。
多次unpark之后调用park，线程会直接执行，因为已经拿到许可令牌了。
许可令牌不会叠加，多次调用park，只有第一次会拿到许可，继续执行，后续的调用则进入等待。
示例：
public void parkUnparkTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (benz == null) { // 如果没奔驰，则进入等待
System.out.println("1、进入等待");
LockSupport.park();
}
System.out.println("2、提到车，回家");
});
consumerThread.start();
// 3秒之后，拉来一辆奔驰
Thread.sleep(3000L);
benz = new Object();
LockSupport.unpark(consumerThread);
System.out.println("3、通知消费者");
}
park/unpark不会释放锁，所以在同步代码块里面使用不当就容易死锁。
死锁示例：
public void parkUnparkDeadLockTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (benz == null) { // 如果没奔驰，则进入等待
System.out.println("1、进入等待");
// 当前线程拿到锁，然后挂起
synchronized (this) {
LockSupport.park();
}
}
System.out.println("2、提到车，回家");
});
consumerThread.start();
// 3秒之后，拉来一辆奔驰
Thread.sleep(3000L);
benz = new Object();
// 争取到锁以后，再恢复consumerThread
synchronized (this) {
LockSupport.unpark(consumerThread);
}
System.out.println("3、通知消费者");
}
消费者挂起之后没有释放锁，生产者永远获取不到锁，死锁。
2.4 join
有人说join也是一种，其实join底层使用的wait/notify
结语
虽然都是些简单例子，但是我们通过这些例子去看正确的操作，还有死锁的情况，我可以在平时写这类代码的时候可以避免踩坑。弃用的suspend/resume就不要用了，wait/notify、park/unpark看场景需要使用。
第一次写博客，排版乱糟糟，有很多知识点还没完全讲到，讲得不够详细，多多谅解。迈出一步，那也是进步。
