孙建博的小站

要想实现多个线程之间的协同，如：线程执行先后顺序、获取某个线程执行的结果等等

涉及到线程之间相互通信，分为下面四类

文件共享

网络共享

略

共享变量

  // 共享变量
  public static String content = "空";
  
  public static void main(String[] args) {
    // 线程1 - 写入数据
    new Thread(() -> {
      try {
        while (true) {
          content = "当前时间" + String.valueOf(System.currentTimeMillis());
          Thread.sleep(1000L);
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    }).start();

    // 线程2 - 读取数据
    new Thread(() -> {
      try {
        while (true) {
          Thread.sleep(1000L);
          System.out.println(content);
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    }).start();
  }

jdk提供的线程协调API

JDK中对于需要多线程协作完成某一任务的场景，提供了对应API支持。

多线程协作的典型场景是：生产者-消费者模型(线程阻塞、线程唤醒)。

示例：线程1去买包子，没有包子，则不再执行。线程2生产出包子，通知线程-1继续执行。

被弃用的suspend和resume

作用:调用suspend挂起目标线程,通过resume可以恢复线程执行

正常的suspend/resume

/** 包子店 */
public static Object baozidian = null;

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

同步代码中使用导致死锁

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

resume比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

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

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则等待"许可(permit)".unpark方法为指定线程提供"许可"

不要求park和unpark方法的调用顺序

多次调用unpark后,再调用park,线程会直接运行,但许可不会叠加,

也就是说,连续多次调用park方法,第一次会拿到"许可"直接运行,后续调用依旧会进入等待.

正常的park/unpark

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

同步代码中使用导致死锁

/** 死锁的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语句来判断，是否进入等待状态，是错误的！(上文代码正常的都是使用的while)
官方建议应该在循环中检查等待条件，原因是处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。

伪唤醒是指线程并非因为notify,notifyall,unpark等api调用而唤醒,是更底层原因导致的