场景一：两个线程进行数据传递，一个线程等待另一个线程的结果

在实际业务场景中，我们大概率会使用Future的方式来得到该结果，但Future必须是当t2线程执行完返回结果后才能在t1线程获取到。但我们可能会碰到t2线程业务很重，而t1线程只需要等待t2完成某一个操作时就能得到该结果继续往下执行，我们该怎么办呢？

保护-暂停模式

核心思想：两个线程共享一个堆内对象，若该对象不满足条件则一直等待，若该对象满足条件则往下执行，t2执行让该对象满足条件。

这个对象需要我们来设计，让他能完成使得两个线程之间的数据传递

@Slf4j(topic = "c.TestGuardedObject")
public class TestGuardedObject {public static void main(String[] args) {GuardedObject guardedObject = new GuardedObject();new Thread(() -> {try {List response = download();log.debug("download complete...");guardedObject.complete(response);} catch (IOException e) {e.printStackTrace();}}).start();log.debug("waiting...");Object response = guardedObject.get();log.debug("get response: [{}] lines", ((List) response).size());}}class GuardedObject {private Object response;private final Object lock = new Object();public Object get() {synchronized (lock) {// 条件不满足则等待while (response == null) {try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}return response;}}public void complete(Object response) {synchronized (lock) {// 条件满足，通知等待线程this.response = response;lock.notifyAll();}}
}

注意：当执行wait操作时将其包裹在while里面而不是if，是为了避免其被虚假唤醒而导致错误的向下执行

场景二：生产者、消费者问题

某类线程专门生产消息，某类线程专门消费消息，但消息与消费者之间并不是一一对应的关系，任意一个消费者都能消费任意一个消息

核心思路：我们设计一个消息队列，生产消息的方法当队满时则阻塞，消费消息的方法当队空时则阻塞

@Slf4j(topic = "c.MessageQueue")
class MessageQueue {private LinkedList queue;private int capacity;public MessageQueue(int capacity) {this.capacity = capacity;queue = new LinkedList<>();}public Message take() {synchronized (queue) {while (queue.isEmpty()) {log.debug("没货了, wait");try {queue.wait();} catch (InterruptedException e) {e.printStackTrace();}}Message message = queue.removeFirst();queue.notifyAll();return message;}}public void put(Message message) {synchronized (queue) {while (queue.size() == capacity) {log.debug("库存已达上限, wait");try {queue.wait();} catch (InterruptedException e) {e.printStackTrace();}}queue.addLast(message);queue.notifyAll();}}
}

场景三：多线程下控制输出顺序

业务场景：三个线程分别输出a,b,c。输入五次，要求交替输出，最后的结果是：abcabcabcabcabc。
核心思想：设置一个公共整型变量status，每个线程对应status一个值，当status=它们对应的值的时候它们才能输出，我们将其封装为一个对象

使用wait\notify

class SyncWaitNotify {private int flag;private int loopNumber;public SyncWaitNotify(int flag, int loopNumber) {this.flag = flag;this.loopNumber = loopNumber;}public void print(int waitFlag, int nextFlag, String str) {for (int i = 0; i < loopNumber; i++) {synchronized (this) {while (this.flag != waitFlag) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.print(str);flag = nextFlag;this.notifyAll();}}}
}

ReentrantLock

@Slf4j(topic = "c.Test28")
public class Test28 {public static void main(String[] args) {AwaitSignal2 as = new AwaitSignal2(3);as.start(new Thread(() -> {as.print("a");}), new Thread(() -> {as.print("b");}), new Thread(() -> {as.print("c");}), new Thread(() -> {as.print("d");}));}
}@Slf4j(topic = "c.AwaitSignal")
class AwaitSignal2 extends ReentrantLock {private Map map = new HashMap<>();public void start(Thread... threads) {Condition[] temp = new Condition[threads.length];for (int i = 0; i < threads.length; i++) {temp[i] = this.newCondition();}for (int i = 0; i < threads.length; i++) {Condition current = temp[i];Condition next;if (i == threads.length - 1) {next = temp[0];} else {next = temp[i + 1];}map.put(threads[i], new Condition[]{current, next});}for (Thread thread : map.keySet()) {thread.start();}try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}this.lock();try {map.get(threads[0])[0].signal();} finally {this.unlock();}}public void print(String str) {for (int i = 0; i < loopNumber; i++) {this.lock();try {Condition[] conditions = map.get(Thread.currentThread());conditions[0].await();log.debug(str);conditions[1].signal();} catch (InterruptedException e) {e.printStackTrace();} finally {this.unlock();}}}// 循环次数private int loopNumber;public AwaitSignal2(int loopNumber) {this.loopNumber = loopNumber;}
}