Guarded Suspension模式

Guarded Suspension模式

顾名思义保护性暂停模式，可以大大降低多线程获取锁时锁冲突带来的性能开销，当线程访问某个数据时，发现无法请求到，此时就会要求线程在进行访问。暂时挂起，保证实例的安全性，等满足条件再去请求。
比如我们如果要开发一个服务器，处理来自客户端的请求。为了不丢失请求，要维护一个缓冲区，将客户端的请求先储存至缓冲区，然后从缓冲区取出请求执行，如果缓冲区没有请求，就等待直到有新的请求过来。

public class Request {
  private String name;

    public Request(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Request{" +
                "name='" + name + '\'' +
                '}';
    }

public class RequestQueue {
    private static Integer MAX_LIMIT = 10;
    private Queue<Request> queue = new LinkedList<>();
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public Request getRequest(){
        Request result = null;
        lock.lock();
        try {
            while (queue.isEmpty()){
                condition.await();
            }
            result = queue.poll();
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
        return result;
    }

    public void putRequest(Request request){
        lock.lock();
        try {
            while (queue.size()>=MAX_LIMIT){
                condition.await();
            }
            queue.offer(request);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}
/**Queue的方法
1、poll() 获取并移除队列的头，如果队列为空那么返回null
2、remove() 获取并移除队列的头，如果队列为空抛出NoSuchElementException
3、peek() 获取队列的头，但是不移除此数据，如果为空返回null
4、Element() 获取队列的头但不移除，如果次队列为空，抛出NoSuchElementException
5、offer() 插入数据，成功返回true，失败返回false（有容量限制时更好）
6、add() 插入数据，（有容量限制时更好）容量满了抛出IllegalStateException
**/

//LinkedBlockingDeque是线程安全的，可以不用加锁
public class RequestQueue {
    private static Integer MAX_LIMIT = 10;
    private Queue<Request> queue = new LinkedBlockingDeque<>(MAX_LIMIT);

    public Request getRequest(){
        Request result = null;
        try {
            while (queue.isEmpty()){
                //等待
                wait();
            }
            result = queue.poll();
           
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    public void putRequest(Request request){
        try {
            while (queue.size()>=MAX_LIMIT){
                //等待
               wait();
            }
            queue.offer(request);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

public class ServerThread extends Thread {
    private Random random;
    private RequestQueue requestQueue;

    public ServerThread(RequestQueue requestQueue,String name,long seed){
        super(name);
        this.random = new Random(seed);
        this.requestQueue =requestQueue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            Request request = requestQueue.getRequest();
            System.out.println(Thread.currentThread().getName()+" handles "+request);
            try {
                Thread.sleep(random.nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ClientThread extends Thread {
    private Random random;
    private RequestQueue requestQueue;

    public ClientThread(RequestQueue requestQueue,String name ,long seed){
        super(name);
        this.random = new Random(seed);
        this.requestQueue = requestQueue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Request request = new Request("N0."+i);
            System.out.println(Thread.currentThread().getName()+" requests "+request.toString());
            requestQueue.putRequest(request);
            try {
                Thread.sleep(random.nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}