多线程学习之三生产者消费者模式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.benxq.thread4;

/**
 * 模拟请求实体
 * Created by qucf on 2015年10月22日. 
 */
public class RequestEntity {

    //请求人的名称
    private String name;
    
    //线程的名称
    private String clientThreadName;

    
    public RequestEntity() {
        super();
    }

    /**
     * @param name
     * @param clientThreadName
     */
    public RequestEntity(String name, String clientThreadName) {
        super();
        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;
    }
    
    @Override
    public String toString() {
        return "生产者："+clientThreadName+"生产者生产的产品"+name+"被消费";
    }
}

请求实体队列类

/**
 * 
 */
package com.benxq.thread4;

import java.util.LinkedList;

/**
 * 模拟请求队列
 * Created by qucf on 2015年10月22日. 
 */
public class RequestQueue {

    //模拟队列容器
    private LinkedList<RequestEntity> list=new LinkedList<RequestEntity>();
    
    //从队列中取出数据
    public synchronized RequestEntity getRequestEntity(){
        //当容器中的数据为0时进入等待状态
        while(list.size()<=0){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //如果不为空，返回第一个请求，并从集合中删除该请求
        return list.removeFirst();
    }
    
    //往队列中加入数据
    public synchronized void putRequestEntity(RequestEntity entity){
        //将加入的数据加入队列尾部
        list.addLast(entity);
        //唤醒所有的线程
        notifyAll();
    }
    
}

生产线程

/**
 * 
 */
package com.benxq.thread4;

import java.util.Random;

/**
 * 模拟请求线程
 * Created by qucf on 2015年10月22日. 
 */
public class ClientThread implements Runnable{

    //存放请求的队列
    private RequestQueue queue;
    
    //随机数
    private Random random;
    
    //线程名称
    private String name;

    

    /**
     * @param queue
     * @param random
     * @param name
     */
    public ClientThread(RequestQueue queue, Random random, String name) {
        super();
        this.queue = queue;
        this.random = random;
        this.name = name;
    }



    @Override
    public void run() {

        for (int i = 0; i < 5; i++) {
            //生成一个请求
            RequestEntity entity=new RequestEntity("No"+i, name);
            
            //将请求放入到队列中
            queue.putRequestEntity(entity);
            
            //让线程休息几秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

消费线程

/**
 * 
 */
package com.benxq.thread4;

import java.util.Random;

/**
 * 消费线程
 * Created by qucf on 2015年10月22日. 
 */
public class ServiceThread implements Runnable{

    //持有线程的队列
    private RequestQueue queue;
    //随机数
    private Random random;
    //线程名
    private String name;
    
    @Override
    public void run() {
        while(true){
            RequestEntity entiry=queue.getRequestEntity();
            System.out.println("消费线程"+name+"----->"+entiry.toString());
            try {
                Thread.sleep(random.nextInt(random.nextInt(1000)));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    /**
     * @param queue
     * @param random
     * @param name
     */
    public ServiceThread(RequestQueue queue, Random random, String name) {
        super();
        this.queue = queue;
        this.random = random;
        this.name = name;
    }

    
}

主线程

/**
 * 
 */
package com.benxq.thread4;

import java.util.Random;

/**
 * 主线程
 * Created by qucf on 2015年10月22日. 
 */
public class Test {

    
    public static void main(String[] args) {
        //声明一个队列
        RequestQueue queue=new RequestQueue();
        
        //生产者线程
        Thread sc1=new Thread(new ClientThread(queue, new Random(), "QQ客户端"));
        Thread sc2=new Thread(new ClientThread(queue, new Random(), "ALIBABA客户端"));
        
        //消费者线程
        Thread xf1=new Thread(new ServiceThread(queue, new Random(), "渠道1"));
        Thread xf2=new Thread(new ServiceThread(queue, new Random(), "渠道2"));
        Thread xf3=new Thread(new ServiceThread(queue, new Random(), "渠道3"));
        
        //开启线程
        sc1.start();
        sc2.start();
        
        xf1.start();
        xf2.start();
        xf3.start();
    }
}