核心意思就是 现在没准备好，等我准备好了通知你啊。

    比如你早上去找你女朋友，打电话说：亲爱的，下楼吧你女朋友说：等我一分钟哈
    就这样你等了半小时，你女朋友轻轻的在背后拍了你一下：走我们去吃大餐吧~~

    我们程序里对象太多了，所以对于有些对象就需要等待，等它准备好了再去做你想要做的事情。

    本质就是 wait notify ，我们实际中用 notifyAll 就好了。在有就是这两个方法，必须在加锁的情况下才能用，不然会报错。

    1. Exception in thread "小明" java.lang.IllegalMonitorStateException
    2.     at java.base/java.lang.Object.notifyAll(Native Method)
    3.     at guarded_suspension.RequestQueue.putRequest(RequestQueue.java:25)
    4.     at guarded_suspension.ClientThread.run(ClientThread.java:18)

    这就设计到管程 monitor了。这个我们会在额外一章节中介绍。记住这个结论就好了。

    举个栗子：

    • Request
    • RequestQueue
    • ClientThread
    • ServiceThread
    • Main
    1. public class Request {
    3.     private String name;
    5.     public Request(String name) {
    6.         this.name = name;
    7.     }
    9.     public String getName() {
    10.         return name;
    11.     }
    13.     @Override
    14.     public String toString() {
    15.         return "Request{" +
    16.                 "name='" + name + '\'' +
    17.                 '}';
    18.     }
    19. }
    1. public class RequestQueue {
    3.     private Queue<Request> requestQueue = new LinkedList<>();
    5.     public synchronized Request getRequest() {
    6.         while (requestQueue.peek() == null) {
    7.             try {
    8.                 System.out.println("wait");
    9.                 wait();
    10.             } catch (InterruptedException e) {
    11.                 e.printStackTrace();
    12.             }
    13.         }
    14.         return requestQueue.remove();
    15.     }
    18.     public synchronized void putRequest(Request request) {
    19.         requestQueue.add(request);
    20.         notifyAll();
    21.         System.out.println("notifyAll");
    22.     }
    23. }
    1. public class ClientThread extends Thread {
    3.    private final RequestQueue requestQueue;
    5.     public ClientThread(String name, RequestQueue requestQueue) {
    6.         super(name);
    7.         this.requestQueue = requestQueue;
    8.     }
    10.     @Override
    11.     public void run() {
    12.         super.run();
    13.         try {
    14.             for (int i = 0; i < 10000; i++) {
    15.                 Request request = new Request("第 " + i + " 个 request");
    16.                 requestQueue.putRequest(request);
    18.                 Thread.sleep(3000);
    20.             }
    21.         } catch (InterruptedException e) {
    22.             e.printStackTrace();
    23.         }
    24.     }
    25. }
    1. public class ServiceThread extends Thread {
    3.     private final RequestQueue requestQueue;
    5.     public ServiceThread(String name, RequestQueue requestQueue) {
    6.         super(name);
    7.         this.requestQueue = requestQueue;
    8.     }
    10.     @Override
    11.     public void run() {
    12.         super.run();
    13.         try {
    14.             for (int i = 0; i < 10000; i++) {
    15.                 Request request = requestQueue.getRequest();
    16.                 System.out.println(request.getName() + "---" + currentThread().getName());
    17.                 Thread.sleep(800);
    19.             }
    20.         } catch (InterruptedException e) {
    21.             e.printStackTrace();
    22.         }
    23.     }
    24. }
    1. public class Main {
    2.     public static void main(String[] args){
    3.         RequestQueue requestQueue = new RequestQueue();
    4.         new ClientThread("小明",requestQueue).start();
    5.         new ServiceThread("服务器端",requestQueue).start();
    6.     }
    7. }

    最后执行结果：

    1. wait
    2. notifyAll
    3. 第 0 个 request---服务器端
    4. wait
    5. notifyAll
    6. 第 1 个 request---服务器端
    7. wait
    8. notifyAll
    9. 第 2 个 request---服务器端
    10. wait
    11. notifyAll
    12. 第 3 个 request---服务器端
    13. wait
    14. notifyAll
    15. 第 4 个 request---服务器端
    16. wait

    当然我们平时不太会自己去写这么多代码，因为逻辑复杂了可能就会有潜在的问题，我们一般直接用 LinkedBlockingQueue 阻塞队列，直接 queue.take() 、queue.put(request) 并不需要 synchronize 也不需要 wait 、 notify，因为阻塞队列已经替我们做了。学会原理，再去用 java 系统的会更加丝滑呦~~