生产者-消费者模式

• 简介

　　生产者-消费者模式是经典的多线程设计模式，它为多线程间的协作提供了良好的解决方案。在生产者-消费者模式中，有两类线程：若干个生产者线程和若干个消费者线程。生产者负责提交用户请求，消费者用于具体的处理生产者提交的任务。生产者和消费者通过共享内存缓冲区进行数据通信。

　　生产者-消费者模式的基本结构如下图：

　　通过上图可以看出，生产者和消费者通过共享内存缓冲区进行通信，他们之间并不进行直接的通信，从而减少了他们之间的耦合，生产者不需要直到消费者的存在，消费者也不需要知道生产者的存在。内存缓冲区主要的功能是实现数据在多线程间的共享，此外，通过该缓冲区，还可以缓解生产者和消费者之间的性能差异。

• 生产者-消费者模式实现

　　下面以生产者-消费者模式的简单实现，介绍该模式的优点：

　　生产者代码：

public class Producer implements Runnable {
    
    private volatile boolean isRunnig = true;
    
    private BlockingQueue<PCData> queue;//缓冲队列
    
    private static AtomicInteger count = new AtomicInteger();
    
    private static final int SLEEPTIME = 1000;
    
    
    public Producer(BlockingQueue<PCData> queue) {
        this.queue = queue;
    }


    @Override
    public void run() {
        PCData pcData = null;
        Random r = new Random();
        
        System.out.println("start producer id:"+Thread.currentThread().getId());
        
        try {
            while(true){
                Thread.sleep(r.nextInt(SLEEPTIME));
                pcData = new PCData(count.incrementAndGet());
                System.out.println(pcData +"is put into queue");
                if(!queue.offer(pcData, 2, TimeUnit.SECONDS)){
                    System.err.println("fail to put data:"+pcData);
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
        
    }
    
    public void stop(){
        isRunnig = false;
    }
    

}

　　消费者代码：

public class Consumer implements Runnable {
    
    private BlockingQueue<PCData> queue;//缓冲队列
    
    private static final int SLEEPTIME=1000;
    
    
    
    public Consumer(BlockingQueue<PCData> queue) {
        this.queue = queue;
    }



    @Override
    public void run() {
        System.out.println("start constomer id:"+Thread.currentThread().getId());
        Random r = new Random();
        try {
            while(true){
                PCData data = queue.take();
                int re = data.getIntData()*data.getIntData();
                System.out.println(MessageFormat.format("{0}*{1}={2}", data.getIntData(),data.getIntData(),re));
                
                Thread.sleep(r.nextInt(SLEEPTIME));
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
        
    }

}

　　消费者、生产者之间的共享数据模型：

public final class PCData {
    private final int intData;

    public PCData(int intData) {
        this.intData = intData;
    }
    
    public PCData(String strData){
        this.intData = Integer.valueOf(strData);
    }
    
    public synchronized int getIntData() {
        return intData;
    }

    @Override
    public String toString() {
        return "data:" + intData;
    }
    
    
    
}

　　在客户端中，启动3个消费者和3个生产者，并让他们协作运行：

public class Client {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<PCData> queue = new LinkedBlockingQueue<PCData>(10); 
        
        Producer  p1 = new Producer(queue);
        Producer  p2 = new Producer(queue);
        Producer  p3 = new Producer(queue);
        
        Consumer  c1 = new Consumer(queue);
        Consumer  c2 = new Consumer(queue);
        Consumer  c3 = new Consumer(queue);
        
        ExecutorService exe = Executors.newCachedThreadPool();
        exe.execute(p1);
        exe.execute(p2);
        exe.execute(p3);
        
        exe.execute(c1);
        exe.execute(c2);
        exe.execute(c3);
        
        Thread.sleep(10*1000);
        
        p1.stop();
        p2.stop();
        p3.stop();
        
        Thread.sleep(3000);
        exe.shutdown();
    }
}    

　　优点：生产者-消费者模式能很好的对生产者线程和消费者线程进行解耦，优化系统的整体结构。同时，由于缓冲区的存在，运行生产者和消费者在性能上存在一定的差异，从而一定程度上缓解了性能瓶颈对系统性能的影响。