保护性暂挂模式（Guarded Suspension）

核心思想
如果某个线程执行特定的操作前需要满足一定的条件，则在该条件未满足时将线程暂停运行（即暂挂线程，使其处于等待（waiting）状态，直到该条件满足时才继续运行）

public class Requets
{
     
    final private String value;

    public Requets(String value) {
     
        this.value = value;
    }

    public String getValue() {
     
        return value;
    }
}

创建一个队列

public class RequestQueue {
     

    private final LinkedList<Requets> queue = new LinkedList<>();

    public Requets getRequest(){
     
        synchronized (queue){
     
            while(queue.size() <= 0){
     
                try {
     
                	// 核心思想，当条件不满足的时候，wait
                    queue.wait();
                } catch (InterruptedException e) {
     
                    return null;
                }

            }
            return queue.removeFirst();
        }
    }

    public void putRequest(Requets requets){
     
        synchronized (queue){
     
            queue.addLast(requets);
            queue.notifyAll();
        }
    }
    
}

// 客户端模拟把数据存入队列
public class ClientThread extends Thread{
     

    private final  RequestQueue queue;
    private final Random random;
    private final String sendValue;
    public ClientThread(RequestQueue queue , String sendValue) {
     
        this.queue = queue;
        this.sendValue = sendValue;
        random = new Random(System.currentTimeMillis());
    }

    @Override
    public void run() {
     
        for (int i = 0; i < 20 ; i++){
     
            System.out.println("Client -> request " + sendValue);
            queue.putRequest(new Requets(sendValue));
            try {
     
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
        }
    }
}

服务端接受

public class ServerThread extends Thread {
     

    private final RequestQueue queue;
    private final Random random;
    private volatile boolean flag = true;

    ServerThread(RequestQueue queue){
     
        this.queue = queue;
        random = new Random((System.currentTimeMillis()));
    }

    @Override
    public void run() {
     
    	// 定义成一直接收，所以需要打断方法
        while (flag){
     
            Requets request = queue.getRequest();
            if(null == request){
     
                System.out.println("received the empty request");
                continue;
            }
            System.out.println("Server -> " + request.getValue());
            try {
     
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
     
               return;
            }
        }
    }

	// 定义一个方法，用来结束线程
    public void close(){
     
        this.flag = false;
        this.interrupt();
    }

}

测试类

    public static void main(String[] args) throws InterruptedException {
     
        final RequestQueue requestQueue = new RequestQueue();
        new ClientThread(requestQueue,"ALEX").start();
        ServerThread serverThread = new ServerThread(requestQueue);
        serverThread.start();
        // 模拟消耗所需要的等待时间
        Thread.sleep(30000);
        serverThread.close();

    }