通讯的方式
要想实现多线程之间的协调，如：线程执行先后顺序，获取某线程执行的结果等待。涉及到线程之间互相通信。分为四类：
1.文件共享
2.网络共享
3.共享变量
4.jdk提供的线程协调API：suspend/reume(弃用), wait/notify, park/unpark
文件共享
变量共享
线程协作 -JDK API
JDK中对应需要多线程协作完成某一任务的场景，提高了对应API支持。
多线程协作的典型场景：生产者-消费者模型。（线程阻塞，线程唤醒）
示例：线程1去买包子，没有包子，则不再执行。线程2生产包子，通知线程1继续执行。
API - 被弃用的suspend和resume
作用：调用suspend挂起目标线程，通过resume可以恢复线程执行。
/** 包子店 */
public static Object baozidian = null;
/** 正常的suspend/resume */
public void suspendResumeTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (baozidian == null) { // 如果没包子，则进入等待
System.out.println("1、进入等待");
Thread.currentThread().suspend();
}
System.out.println("2、买到包子，回家");
});
consumerThread.start();
// 3秒之后，生产一个包子
Thread.sleep(3000L);
baozidian = new Object();
consumerThread.resume();
System.out.println("3、通知消费者");
}
被弃用的主要原因，容易写出死锁的代码。所有用wait/notify和park和unpark机制对他镜像代替。
suspend和resume死锁示例：
第一种：同步代码块中使用：死锁的suspend/resume。 suspend并不会像wait一样释放锁，故此容易写出死锁代码
/** 死锁的suspend/resume。 suspend并不会像wait一样释放锁，故此容易写出死锁代码 */
public void suspendResumeDeadLockTest() throws Exception {
// 启动线程
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(3000L);
baozidian = new Object();
// 争取到锁以后，再恢复consumerThread
synchronized (this) {
consumerThread.resume();
}
System.out.println("3、通知消费者");
}
第二种：执行顺序问题(suspend比resume后执行)：线程内执行慢，线程外的esume先执行了，suspend永久挂起。
/** 导致程序永久挂起的suspend/resume */
public void suspendResumeDeadLockTest2() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (baozidian == 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);
baozidian = new Object();
consumerThread.resume();
System.out.println("3、通知消费者");
consumerThread.join();
}
wait/notify机制
这些方法只能由同一对象锁的持有者线程调用，也就是写在同步代码块里面，否则会抛出IllegalMonitorStateException异常。
wait方法导致当前线程等待，加入该对象等待集合中，并且放弃当前持有者的对象锁。
notify/notifyAll方法幻想一个或者所有正在等待这个对象锁的线程。
注意：虽然会wait自动解锁，但是对顺序有要求，如果在notify被调用之后，才开始wait方法调用，线程会永久处于waiting状态。
wait/notify代码示例
1.正常输出：在进入线程之后，马上执行wait，之后释放锁，能拿到锁。
/** 正常的wait/notify */
public void waitNotifyTest() throws Exception {
// 启动线程
new Thread(() -> {
synchronized (this) {
while (baozidian == null) { // 如果没包子，则进入等待
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、通知消费者");
}
}
2.锁死，一直等待。在执行线程时没有马上wait，而是先休眠了5秒，此时下面的notify已执行完，notify比wait要先执行，锁死。
/** 会导致程序永久等待的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、通知消费者");
}
}
park/unpark机制
线程调用park则等待"许可"，unpark方法为指定线程提供"许可(permit)"
不要求park和unpark方法的调用顺序。同时它们是不释放锁的
多次调用unpark之后，再调用park，线程会直接运行。但是不会叠加，也就是说，连续多次调用park方法，第一次会拿到“许可”直接运行，后续调用会进入等待。
1.正常，不要求park和unpark方法的调用顺序。
/** 正常的park/unpark */
public void parkUnparkTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
while (baozidian == null) { // 如果没包子，则进入等待
try {
Thread.sleep(5000L); //后执行park可以，它不要求调用顺序
} catch (InterruptedException e) {
e.printStackTrace();
}
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、通知消费者");
}
}
2.不正常，同步代码块的使用，不进行释放锁，导致锁死。
/** 死锁的park/unpark */
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语句来判断，释放进入等待状态是错误的。将上面所有的if (baozidian == null)改为while(baozidian == null)
官方建议应该在循环中简称等待条件，原因是处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中简称等待条件，程序就会在没有满足解锁条件的情况下退出。
伪唤醒是指线程并非因为notify,notifyall,unpark等api调用而唤醒，是更底层原因导致的。
//wait
synhronized(obj){
while(<条件判断>)
obj.wait();
....//执行后续操作
}
//park
while(<条件判断>)
LockSupport.aprk()
....//执行后续操作
