这是一种是用很多的设计模式, 其核心思想就是服务线程开始就准备好，不断查看是否有新的请求，如果有新的请求，就处理。但事实上，服务端的处理能力很有可能有限，但是作为程序的健壮性，不可能丢掉任何一个客户端请求，这种一个比较好的方案就是对客户端的请求进行排队，放到队列里面，然后服务线程一个一个处理。这样至少能避免服务端处理太多请求而崩溃。

如下例子假设：程序一开始就开启10个服务线程，一直处于等待状态，查看队列中是否有新的请求，如果有就处理。 当服务线程准备好之后，客户端就可以发出请求，这里模拟了10个客户线程，每一个客户线程发起10次请求，中间间隔10毫秒。假设每个服务进程处理一个请求需要100毫秒。明显时间比较长，没办法及时处理客户端请求. 一下代码就是这种模式的核心代码:

服务端线程package com.yihaomen.gs;

public class ServerThread extends Thread {

private RequestQueue requestQueue;

public ServerThread(RequestQueue requestQueue, String name) {

super(name);

this.requestQueue = requestQueue;

}

public void run() {

// 线程一直存在，直到进程结束. 守护线程。

while (true) {

final Request request = requestQueue.getRequest();

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " handles " + request);

}

}

}

客户线程

package com.yihaomen.gs;

public class ClientThread extends Thread {

private RequestQueue requestQueue;

public ClientThread(RequestQueue requestQueue, String name) {

super(name);

this.requestQueue = requestQueue;

}

public void run() {

for (int i = 0; i < 10; i++) {

Request request = new Request("RequestID:" + i+" Thread_Name:"+Thread.currentThread().getName());

System.out.println(Thread.currentThread().getName() + " requests " + request);

requestQueue.addRequest(request);

try {

Thread.sleep(10);

} catch (InterruptedException e) {

}

System.out.println("ClientThread Name is:"+Thread.currentThread().getName());

}

System.out.println(Thread.currentThread().getName()+" request end");

}

}

模拟测试

package com.yihaomen.gs;

public class Main {

public static void main(String[] args) {

RequestQueue requestQueue = new RequestQueue();

for(int i=0;i<10;i++) {

new ServerThread(requestQueue, "ServerThread"+i).start();

}

for(int i=0;i<10;i++){

new ClientThread(requestQueue, "ClientThread"+i).start();

}

}

}

当客户端请求处理完之后， 10个服务线程仍然在继续工作，继续等待新的请求，这种模式保证了客户端请求不会丢失，同时服务线程也不会承受大量并发的请求从而导致计算机资源的不足.

测试代码下载:

java thread guarded suspension pattern sample code