线程通信

线程通信，指多个线程在运行期间，进行的数据交互或者协作。

通信方式

要想实现多个线程之间的协同，如：线程执行先后顺序、获取某个线程执行的结果等等。
涉及到线程之间相互通信，分为下面四类：

1. 文件共享
2. 网络共享
3. 变量共享
4. jdk提供的线程协调API
   分为：suspend/resume；wait/notify；park/unpark

文件共享

线程1和线程2，向同一个文件读写数据。
线程1向文件写入数据，线程2从文件读取数据。

网络共享

与文件共享类似

变量共享

有一个公共变量，线程1把数据写入到变量中，线程2读取数据，实现两个线程之间数据交互。

线程协作——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机制进行替代。
死锁示例1：
suspend挂起的时候，不会释放锁，在使用同步代码的时候，消费者会获得这把锁，然后挂起；生产者没办法获取到锁，没办法恢复线程继续执行。

/** 死锁的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、通知消费者");
	}

死锁示例2：
suspend要比resume先执行，否则会发生死锁

/** 导致程序永久挂起的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被调用之后，才开始wair方法的调用，线程会永远处于WAITING状态。
代码示例：
wait和notify一定要在同步代码中使用，基于对象的等待集，也就是说，基于监视器机制实现的。如果不再同步代码块中实现，会发生异常。

/** 正常的wait/notify */
	public void waitNotifyTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				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、通知消费者");
		}
	}

死锁代码示例：

/** 会导致程序永久等待的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方法，第一次会拿到”许可“直接运行，后续调用会进入等待。

代码示例：
需要借助LockSupport工具类。park/unpark先后顺序，不重要。

/** 正常的park/unpark */
	public void parkUnparkTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (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、通知消费者");
	}

死锁代码示例：
不会对锁进行释放，并不是基于监视器锁的方式去实现的，jvm底层提供的另一种挂起线程方式，和wait/notify有区别。

/** 死锁的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语句来判断，是否进入等待状态，是错误的！
官方建议：应该在循环中检查等待条件，原因是处于等待状态的线程可能会受到错误警报和伪唤醒，如果不在循环中检查等待条件，程序会在没有满足条件的情况下退出。
伪唤醒是指，线程并非因为notify、notifyAll、unpark等api调用而唤醒，是更底层原因导致的。