Java多线程GuardedSuspension模式

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。