Java程序性能优化 读书笔记（十二）并行设计模式：Guarded Suspension模式

一、Guarded Suspension模式

Guarded Suspension意为保护暂停，其核心思想是仅当服务进程准备好时，才提供服务。设想一种场景，服务器可能会在很短时间内承受大量的客户端请求，客户端请求的数量可能超过服务器本身的即时处理能力，而服务端程序又不能丢弃任何一个客户请求。此时，最佳的处理方案莫过于让客户端要求进行排队，由服务端程序一个接一个处理。这样，既保证了所有的客户端请求均不丢失，同时也避免了服务器由于同时处理太多的请求而崩溃。

二、Guarded Suspension模式的结构

Guarded Suspension模式的主要成员有：Request、RequestQueue、ClientThread、ServerThread

Request：表示客户端请求

RequestQueue：用于保存客户端请求队列

ClientThread：客户端进程

ServerThread：服务器进程

其中，ClientThread负责不断发起请求，并将请求对象放入请求队列。ServerThread则根据其自身的状态，在有能力处理请求时，从RequestQueue中提取请求对象加以处理。系统的工作流程如图

三、Guarded Suspension模式的实现

Request类封装了请求的内容

package com.zenhobby;

public class Request {
private String name;

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

public String getName() {
return name;
}

@Override
public String toString() {
return "[ Request "+ name + " ]";
}
}

RequestQueue对象作为Request的集合，维护系统的Request请求列表

package com.zenhobby;

import java.util.LinkedList;

public class RequestQueue {
private LinkedList<Request> queue = new LinkedList<>();
public synchronized Request getRequest() {
while (queue.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return queue.removeFirst();
}

public synchronized void addRequest(Request request) {
queue.add(request);
notifyAll();
}
}

服务端进程用于处理用户的请求操作，代码实现如下

package com.zenhobby;

public class ServerThread extends Thread {
private RequestQueue requestQueue;

public ServerThread(RequestQueue requestQueue, String name) {
super(name);
this.requestQueue = requestQueue;
}

@Override
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.zenhobby;

public class ClientThread extends Thread {
private RequestQueue requestQueue;

public ClientThread(RequestQueue requestQueue, String name) {
super(name);
this.requestQueue = requestQueue;
}

@Override
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) {
e.printStackTrace();
}
System.out.println("ClientThread Name is: " + Thread.currentThread().getName());
}
System.out.println(Thread.currentThread().getName() + "request end");
}
}

主函数如下

package com.zenhobby;

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();
}
}
}

RequestQueue起到了中间缓存的作用，从程序执行结果来看，当所有的ClientThread全部运行结束后，Server进程并没有停止工作，而是继续处理RequestQueue中的请求，直至处理完毕，Client的请求并未丢失。

四、带返回值的Guarded Suspension模式

上述的Guarded Suspension模式中Request'的请求并无返回值，因此客户端无法得知请求的执行情况，因此采用Future模式对Guarded Suspension模式进行增强可以构造带返回值的Guarded Suspension模式。

首先，客户进程和服务进程对于请求队列的处理和改进前完全一致，只是服务进程在数据处理时添加了对Request中response的数据处理，服务进程会在其工作过程中将返回数据设置到response中，当客户端访问数据时若服务进程尚未完成，则客户端需要等待，否则客户端直接获取数据，与Future模式一致。

将原模式中的Request类进行扩展，嵌入Future模式中的Data接口，用于传递服务器返回的数据。

package com.zenhobby;

public class Request {
private String name;
private Data response;

public synchronized Data getResponse(){
return response;
}
public synchronized void setResponse(Data response){
this.response = response;
}

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

public String getName() {
return name;
}

@Override
public String toString() {
return "[ Request "+ name + " ]";
}
}

Data类的实现与Future中的实现完全一致；

Server中需要添加对返回值的处理

package com.zenhobby;

public class ServerThread extends Thread {
private RequestQueue requestQueue;

public ServerThread(RequestQueue requestQueue, String name) {
super(name);
this.requestQueue = requestQueue;
}

@Override
public void run() {
while (true) {
final Request request = requestQueue.getRequest();
final FutureData future = (FutureData)request.getResponse();
RealData realdata = new RealData(request.getName());
future.setRealData(realdata);
System.out.println(Thread.currentThread().getName() + " handles " + request);
}
}
}

客户端中也要添加对返回值的处理

package com.zenhobby;

public class ClientThread extends Thread {
private RequestQueue requestQueue;
private List<Request> myRequest = new ArrayList<Request>();
public ClientThread(RequestQueue requestQueue, String name) {
super(name);
this.requestQueue = requestQueue;
}

@Override
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);
//设置一个FutureData的返回值
request.setResponse(new FutureData());
requestQueue.addRequest(request);
myRequest.add(request);
try {
Thread.sleep(1000);  //做一些额外的业务等待服务器装配数据
} catch (InterruptedException e) {
e.printStackTrace();
}
for (Request r:myRequest) {
System.out.println("ClientThread Name is:"+
Thread.currentThread().getName()+
" Response is:"+
r.getResponse().getResult);//阻塞等待结果
}
}
}
}

Guarded Suspension模式在一定程度上可以缓解系统的压力，它可以将系统的负载在时间轴上均匀地分配，降低系统的瞬时负载，UI提高系统的抗压能力和稳定性有一定的帮助。