多线程程序设计学习（4）guarded suspension模式

Guarded Suspension【生产消费者模式】

一:guarded suspension的参与者
--->guardedObject(被防卫)参与者
                1.1该参与者拥有一个被防卫的方法（getRequest）,如果警戒条件达成，则执行。警戒条件不达成，则线程进入wait set
                1.2该参与者还拥有一个改变参与者状态的方法（putRequest）。参与者的状态影响着警戒条件的是否达成。

--->该模式的角色：生产端线程，消费端线程，传递数据的摇篮（被防卫的参与者）

二：guarded suspension模式什么时候使用
--->适合交易系统使用。客户端下单，服务端处理订单。高并发，大量数据处理的模式，增强服务的吞吐量

三：guarded suspension思考
--->与该模式共通的三个特征
                3.1:有循环存在
                3.2:有条件测试
                3.3:有因某种原因的等待

---> guarded wait 被阻断而等待
        等待端范例：
        while(条件){
                wait();
        }
        唤醒端范例：
                条件=true
                notifyAll();
---> busy wait 忙碌地等待
        yield，尽可能把优先级交给其他线程，那个线程调用此方法，那个线程暂时一次让出CPU调度权。至于能否暂停，实际看cpu是否去掉别的线程。我主动放弃一次，至于cpu走不走，看cpu的。yield不会解除锁定，所以这段代码不可写在snychronized里。而ready字段必须声明成volatile
        等待端范例：
        while(ready){
                Thead.yield();
        }
        唤醒端范例：
        ready=true

---> spin lock 旋转而锁定
        旋转而锁定的意思，表现出条件成立前while循环不断"旋转"的样子，spin lock有时意思与guarded wait相同，有时则与busy wait相同。另外，有时候则是指一开始使用busy wait ,之后再切换成guarded wait方式。另外有些硬件实现的同步机制

--->polling
" 进行舆论调查"的意思，反复检查某个事件是否发生，当发生时就进行对应的处理。

模仿队列（传递数据）

 package com.yeepay.sxf.thread3;

 import java.util.LinkedList;

 /**
  * 存放实体的队列
  * @author sxf
  *
  */
 public class RequestEntryQueue {
     //存放请求的链表集合
     private final LinkedList<RequestEntry> list=new LinkedList<RequestEntry>();

     //从队列中取出请求
     public synchronized  RequestEntry getRequestEntry(){
         //判断存放请求的集合是否存在，请求，不存在，就让当前消费着线程进入wait set
         while (list.size()<=0) {
             try {
                  wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         }
         //如果不为空，则返回第一个请求，并从集合中删除该请求
         return  list.removeFirst();
     }

     //往队列中放入请求
     public synchronized void putRequestEntry(RequestEntry requestEntry){
         //将新的请求放入队列
         list.addLast(requestEntry);
         //唤醒所有wait set中的线程
         notifyAll();
     }
 }

请求实体

 package com.yeepay.sxf.thread3;
 /**
  * 请求实体
  * @author sxf
  *
  */
 public class RequestEntry {
     //请求人的名字
     private String name;
     //线程的名字
     private String clientThreadName;

     public RequestEntry() {
         super();
     }

     @Override
     public String toString() {
         // TODO Auto-generated method stub
         return "["+clientThreadName+"生产线程]生产的商品"+name+"被消费";
     }

     public RequestEntry(String name,String clientThreadName) {

         this.name = name;
         this.clientThreadName=clientThreadName;

     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getClientThreadName() {
         return clientThreadName;
     }

     public void setClientThreadName(String clientThreadName) {
         this.clientThreadName = clientThreadName;
     }

 }

客户端线程

 package com.yeepay.sxf.thread3;

 import java.util.Random;

 /**
  * 客户端线程
  * @author sxf
  *
  */
 public class ClientThread implements Runnable{
     //存放请求的队列
     private RequestEntryQueue requestEntryQueue;
     //随即数
     private Random random;
     //线程名字
     private String name;

     //构造器
     public ClientThread(RequestEntryQueue requestEntryQueue, Random random,String name) {
         super();
         this.requestEntryQueue = requestEntryQueue;
         this.random = random;
         this.name=name;
     }

     @Override
     public void run() {
         for(int i=0;i<1000;i++){
             //生成一个请求
             RequestEntry requestEntry=new RequestEntry("No"+i,name);
             //将该请求存入队列
             requestEntryQueue.putRequestEntry(requestEntry);
             //让线程休息几秒
             try {
                 Thread.sleep(random.nextInt(1000));
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }

     }

 }

服务端线程

 package com.yeepay.sxf.thread3;

 import java.util.Random;

 /**
  * 服务线程
  * @author sxf
  *
  */
 public class ServiceThread implements Runnable{
     //持有存放请求的队列
     private RequestEntryQueue requestEntryQueue;
     //随即数
     private Random  random;
     //线程名字
     private String name;

     public ServiceThread(RequestEntryQueue requestEntryQueue, Random random,
             String name) {
         super();
         this.requestEntryQueue = requestEntryQueue;
         this.random = random;
         this.name = name;
     }

     @Override
     public void run() {
         while(true){
             RequestEntry requestEntry=requestEntryQueue.getRequestEntry();
             System.out.println("【消费者线程"+name+"】----------->"+requestEntry.toString());

             try {
                 Thread.sleep(random.nextInt(1000));
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }

     }

 }

测试类

 package com.yeepay.sxf.thread3;

 import java.util.Random;

 /**
  * 测试类
  * @author sxf
  *
  */
 public class Test {

     public static void main(String[] args) {
         //声明一个队列
         RequestEntryQueue requestEntryQueue=new RequestEntryQueue();
         //声明两个生产者线程
         Thread clientThread1=new Thread(new ClientThread(requestEntryQueue, new Random(), "QQ客户端"));
         Thread clientThread2=new Thread(new ClientThread(requestEntryQueue, new Random(), "ALIBABA客户端"));
         //声明三个消费者线程
         Thread serviceThread1=new Thread(new ServiceThread(requestEntryQueue, new Random(), "易宝支付"));
         Thread serviceThread2=new Thread(new ServiceThread(requestEntryQueue, new Random(), "支付宝"));
         Thread serviceThread3=new Thread(new ServiceThread(requestEntryQueue, new Random(), "财付通"));
         //开启线程
         clientThread1.start();
         clientThread2.start();

         serviceThread1.start();
         serviceThread2.start();
         serviceThread3.start();

     }
 }