使用BlockingQueue来简化消费者与生产者的问题

之前我们已经用常用方法写了一个消费者与生产者程序，不过看上去有点烦。在JDK 5里面，Java为我们提供了一个可以简化这方面开发的的接口

java.util.concurrent.BlockingQueue

使用BlockingQueue,我们的程序可以这样写

import  java.util.concurrent.BlockingQueue;

public   class  ConsumerBlockingQueue  extends  Thread  {

    private final BlockingQueue<Integer> queue;
    private final String name;
    
    public ConsumerBlockingQueue(BlockingQueue<Integer> q, String name)
    {
        queue=q;
        this.name=name;
    }
    public void run() {
        // TODO Auto-generated method stub
        try
        {
            while(true)
            {
                consume(queue.take());
                try
                {
                    sleep(800);// 将消费者的睡眠时间设置得比生产者小是为了演示当产品列表为空的情形
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    
    private void consume(int i)
    {
        System.out.println(name+" consume "+i);
    }

}

这个是消费者类。

public   class  ProducerBlockingQueue  extends  Thread {
    
    private final BlockingQueue<Integer> queue;
    private final String name;
    private static int i=0;
    public ProducerBlockingQueue(BlockingQueue<Integer> q, String name)
    {
        queue=q;
        this.name=name;
    }
    
    public void run() {
        // TODO Auto-generated method stub
        try
        {
            while(true)
            {
                queue.add(produce());
                try
                {
                    sleep(1000);
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
                
        }catch(Exception e){
            e.printStackTrace();
        }

    }
    
    private int produce()
    {
        System.out.println(name+" producing "+i);
        return i++;
    }

}

这个是生产者类。

import  java.util. * ;
import  java.util.Collection;
import  java.util.Iterator;
import  java.util.concurrent.BlockingQueue;
import  java.util.concurrent.TimeUnit;

public   class  Queue  implements  BlockingQueue  {

    private List list=new ArrayList();
    public boolean add(Object o) {
        // TODO Auto-generated method stub
        list.add(o);
        return true;
    }

    public Object take() throws InterruptedException {
        // TODO Auto-generated method stub
        while(isEmpty()){}
        return list.remove(0);
    }


    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return list.isEmpty();
    }

// 当然这个类还有其他的方法需要实现，为了清楚起见，我把使用默认实现的方法都去掉了。

}

我们定义一个Queue来实现BlockingQueue。下面我们来测试下

import  java.util.concurrent.BlockingQueue;


public   class  Test  {

    /** *//**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BlockingQueue<Integer> q=new Queue();
        ProducerBlockingQueue p=new ProducerBlockingQueue(q,"p");
        ProducerBlockingQueue p1=new ProducerBlockingQueue(q,"p1");
        ConsumerBlockingQueue c=new ConsumerBlockingQueue(q,"c");
        ConsumerBlockingQueue c1=new ConsumerBlockingQueue(q,"c1");
        p.start();
        p1.start();
        c.start();
        c1.start();
    }

}