Guarded Suspension 模式
Guarded是被保护、被守护的意思，Suspension是暂停的意思。就是说线程执行当前的处理会有问题，需要让线程处理等待一下。
实例程序
程序会用一个线程把请求的实例传给另一个线程，相对简单的线程间通信。
Request类
public class Request {
private final String name;
public Request(String name) {
this.name = name;
}
public String getName() {
return name;
}
public String toString() {
return "[ Request " + name + " ]";
}
}
RequestQueue 类
import java.util.Queue;
import java.util.LinkedList;
public class RequestQueue {
private final Queue<Request> queue = new LinkedList<Request>();
public synchronized Request getRequest(){
while (queue.peek() == null ){
try{
wait();
} catch (InterruptedException e){
}
}
return queue.remove();
}
public synchronized void putRequest(Request request){
queue.offer(request);
notifyAll();
}
}
ClientThread类
用于发送请求的线程。ClientThread持有RequestQueue的实例，并调用此实例放入请求。
import java.util.Random;
public class ClientThread extends Thread {
private final Random random;
private final RequestQueue requestQueue;
public ClientThread(RequestQueue requestQueue, String name, long seed){
super(name);
this.requestQueue = requestQueue;
this.random = new Random(seed);
}
public void run() {
for(int i = 0; i < 10000; i++){
Request request = new Request("No." + i);
System.out.println(Thread.currentThread().getName() + " requests " + request);
requestQueue.putRequest(request);
try{
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {}
}
}
}
ServerThread 类
用于接受请求的线程，持有RequestQueue的实例，使用getRequest方法接受请求。
import java.util.Random;
public class ServerThread extends Thread {
private final Random random;
private final RequestQueue requestQueue;
public ServerThread(RequestQueue requestQueue, String name, long seed){
super(name);
this.requestQueue = requestQueue;
this.random = new Random(seed);
}
public void run(){
for(int i = 0; i < 10000; i++) {
Request request = requestQueue.getRequest();
System.out.println(Thread.currentThread().getName() + " handles " + request);
try{
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e){}
}
}
}
Main类
Main类创建RequestQueue的实例，然后分别创建多个ClientThread类的实例，并让ClientThread的所有实例从RequestQueue存入和获取请求，然后运行线程。
public class Main {
public static void main(String[] args){
RequestQueue requestQueue = new RequestQueue();
new ClientThread(requestQueue, "Alice", 31415926L).start();
new ClientThread(requestQueue, "Bobby", 6535897L).start();
}
}
java.util.Queue与java.util.LinkedList的操作
- Request remove()
从队列移除第一个元素，并返回该元素，如队列无元素，则抛出java.util.NoSuchElementException异常。 - boolean offer(Request req)
将元素req添加到队列末尾 - Request peek()
如果队列存在元素，则该方法会返回头元素；如果为空，则返回null。该方法并不移除元素。
java.util.LinkedList类是非线程安全的。
java.util.concurrent.LinkedBlockingQueue是线程安全。
getRequest 详解
getRequest 方法
public synchronized Request getRequest(){
while(queue.peek() == null){
try{
wait();
} catch (InterruptedException e){}
}
return queue.remove();
}
- 守护条件进行保护
getRequest方法应该执行的“目标处理”是什么。该方法的目的是“从queue中取出一个Request实例”，也就是执行下面的这条语句
queue.remove();
但是，为了安全执行这条语句，必须满足如下条件。
queue.peek() != null
该条件就是“存在想要取出的元素”。这种必须要满足的条件就称为Guarded Suspension模式的守护条件（guard condition）。
queue.peek() != null ----守护条件
当守护条件的逻辑不成立时，绝对不会执行后面的语句（调用remove）。 - 不等待的情况和等待的情况
当线程执行while语句时，需要考虑守护条件成立与不成立这两种情况。 - 执行 wait， 等待条件发生变化
当守护条件不成立时，线程执行wait，开始等待，那到底在等待什么呢？
“是在等待notify/notifyAll。” 正在wait的线程如果不被notify/notifyAll，便会一直在等待队列中。不过，我们需要思考一下更深层的含义。线程真正等待的是实例状态的变化。线程之所以等待，是因为守护条件未满足，也就是该守护条件进行了保护，从而阻止了线程继续向前执行。线程等待的实例状态发生变化，守护条件成立的时候。 - 执行到while 的下一条语句时一定能确定的事情
getRequest方法，如果while的下一条语句肯定会执行，那么执行时， while语句的守护条件一定是成立的，也就是说，调用remove方法时，“queue中存在可供取出的元素”，所以remove方法绝对不会抛出NoSuchElementException异常。
putRequest 详解
public synchronized void putRequest(Request request){
queue.offer(request);
notifyAll();
}
执行offer方法，向queue的末尾添加一个请求（request）。这时，queue中至少存在一个可供取出的元素。因此，下面的表达式为真。
queue.peek() != null
在getRequest中，正在wait的线程等待的是什么呢？就是上面这个条件，即守护条件成立。那么，这里就执行notifyAll唤醒等待的线程。
synchronized的含义
getRequest和putRequest方法中都使用了synchronized。synchronized保护的是queue字段（LinkedList的实例）。例如getRequest方法中的处理必须确保同时“只能有一个线程执行”。这就是Single Threaded Execution模式。
wait与锁
线程执行某个实例的wait方法。这时，线程必须获取实例的锁。上面的synchronized方法中，wait方法被调用，获取的就是this的锁。
线程执行this的wait方法后，就进入this的等待队列，并释放持有的this锁。
notify、notifyAll或interrupt会让线程退出等待队列，但在实际地继续执行处理之前，还必须再获取this锁。
Guarded Suspension模式中的登场角色
GuardedObject（被守护的对象）
GuardedObject角色是一个持有被守护的方法（guardedMethod）的类。当线程执行guardedMethod方法时，若守护条件成立，则可以立即执行；当守护条件不成立时，就要进行等待。守护条件的成立与否会随着GuardedObject角色的状态不同而发生变化。
除了guardedMethod之外，GuardedObject角色还有可能持有其他改变实例状态（特别是改变守护条件）的方法（stateChangingMethod）。
在Java中，guardedMethod通过while语句和wait方法来实现。stateChangingMethod则通过notify/notifyAll方法来实现。
在示例程序中，由RquestQueue角色类扮演此类。getRequest方法队形guardedMethod，putRequest方法则对应stateChangingMethod。
