使用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++;
    }

}

 

我们定义一个Queue来实现BlockingQueue

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();
    }

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

}

 

下面我们来测试下

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();
    }

}

 

看到没有，就这么简单，以很少的逻辑代码实现了消费者与生产者功能，当然你还可以对他进行扩充，让他更加完善。