Java多线程设计模式详解学习笔记五——GuardedSuppension

public class Main {
	public static void main(String[] args) {
	    RequestQueue requestQueue=new RequestQueue();
	    new ClientThread("Alice",requestQueue,  3141592L).start();
	    new ServerThread("Bobby",requestQueue,  6535897L).start();
	}
}

public class Request {
	private final String name;
	
	public Request(String name) {
		this.name=name;
	}
	
	@Override
	public String toString() {
		return "[ Request "+name+"]";
	}
}

public class RequestQueue {
	private final LinkedList<Request> queue=new LinkedList<Request>();
	
	public synchronized Request getRequest() {
		if (queue.size()<=0) {
			try {
				wait();//this.wait();当前执行的线程在this上等待，也就是在RequestQueue实例对象上面等待
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return queue.removeFirst();
	}
	
	public synchronized void putRequest(Request request) {
	      queue.addLast(request);
	      notifyAll();
	}
}

public class ClientThread extends Thread{
	
	private Random random;
	private RequestQueue requestQueue;
	
	public ClientThread(String name,RequestQueue requestQueue,long seed) {
		super(name);
		this.requestQueue=requestQueue;
		random=new Random(seed);
	}
	
	@Override
	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) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

public class ServerThread extends Thread{
	private Random random;
	private RequestQueue requestQueue;
	
	public ServerThread(String name,RequestQueue requestQueue,long seed) {
		super(name);
		this.requestQueue=requestQueue;
		random=new Random(seed);
	}
	
	@Override
	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) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

运行结果：

Alice requests [ Request No.0]
Bobby handles [ Request No.0]
Alice requests [ Request No.1]
Alice requests [ Request No.2]
Bobby handles [ Request No.1]
Bobby handles [ Request No.2]
Alice requests [ Request No.3]
Bobby handles [ Request No.3]
Alice requests [ Request No.4]
Bobby handles [ Request No.4]
Alice requests [ Request No.5]
Alice requests [ Request No.6]
Bobby handles [ Request No.5]
Bobby handles [ Request No.6]
Alice requests [ Request No.7]
Bobby handles [ Request No.7]
Alice requests [ Request No.8]
Bobby handles [ Request No.8]
Alice requests [ Request No.9]
Bobby handles [ Request No.9]
Alice requests [ Request No.10]
Alice requests [ Request No.11]
Bobby handles [ Request No.10]
Bobby handles [ Request No.11]

执行wait等待条件的变化：

执行wait的时候，线程是在等待什么？线程真正所等待的，是实例状态的变化。等待中的线程，正等待着警戒条件的变化。

只有了解“线程在等待什么”，就知道何时应该“调用notify/notifyAll”,也就是说在等待的东西完成的地方调用notify/notifyAll

wait与锁定：

当某个线程试图去执行某个实例的wait方法时，这个线程必须获取改实例的锁定。在synchronized方法中调用wait方法，在执行wait的时候，的确线程正获取this的锁定 。然而当线程执行this的wait方法后，会进入wait的等待区，这时，线程就会解除this的锁定。而线程可能会因为notify、notifyAll、或interrupt退出等待区。不过在实际执行下一个语句之前，必须再次获得this的锁定才行。

wait与notify、notifyAll的责任（复用性）：

程序中只有RequestQueue类有用到wait/notifyAll，在ClientThread、ServerThread、Main等其他类中都没有出现wait/notifyAll。Guarded Suspension Pattern的实现是封装在RequestQueue类里的。之所以隐藏wait/notifyAll，是为了RequestQueue类的复用性。使用RequestQueue类的一方，并不需要考虑wait/notifyAll的问题，只要调用getRequest方法与putRequest方法就行了。

guarded wait:

意义是“被阻挡而等待”，线程使用wait等待，等到被notify/notifyAll再次测试条件的实例方法。使用wait等待的时间，其实是停止在停止在等待区里停止执行，所以不会浪费java执行环境的处理时间。

等待端的范例：

while(!ready)

{
     wait();
}

唤醒端范例：

ready=true;
notifyAll;

busy wait：

“忙碌等待”的意思，线程不适用wait等待，而是用yield（进可能把优先级让给其他线程），并不断测试条件的方法。因为等待中的线程也持续运行着，所以会浪费java虚拟机的时间。yield是Thread累的类方法。

等待端的范例：

while(!ready){
    Thread.yield();
}

唤醒端的范例：

ready=true;