基于并发包同步机制实现生产者-消费者模式

上一篇我们使用jdk原始的同步机制实现了生产者-消费者模式，这次我们改用jdk1.5中提供的相关并发类实现生产者-消费者模式。

先说明两个类（接口）

• ReentrantLock类
  
  • 作用跟synchronized代码块差不多，都是用于实现互斥，当然两者是有区别的。
• Condition接口
  
  • 它提供了await()、signal()、signalAll()等方法，作用于Object类的wait()、signal()和signalAll()方法一样。注意由于它是一个接口，因此是不能new出来的，我们必须通过ReentrantLock类的newCondition方法得到一个Condition对象（实际上是ConditionObject类对象），这个对象与该ReentrantLock对象相关联。

同样，Condition的await()、signal()、signalAll()都必须在获得相对应的ReentrantLock锁才能进行调用

注意这里我们可以使用同一个ReentrantLock对象多次调用newCondition获得多个Condition对象，以实现更加复杂的同步关系，而使用Object类的相当于只能有一个Condition对象。当然，在不同的Condition对象中，等待和唤醒要相对应，比如说，我们两次调用newCondition方法，得到了两个Condition对象condition1和condition2，假如我在线程A调用condition1.await()，然后线程B调用了condition2.signal()，那么线程A是一定不会因此被唤醒的，而应该调用condition1.signal()线程A才可能会被唤醒，为什么说可能而不是一定呢？原因是signal()同Object类的notify()是一样的，系统会随机唤醒等待集中的一个线程，而我们的线程A不一定会被选到。

实现生产者-消费者模式（阻塞队列）：

public class ProducerConsumerCondition {    private int bufSize;    private int[] buf;    private int currentSize;    private ReentrantLock mainLock = new ReentrantLock();    private Condition putCondition = mainLock.newCondition();    private Condition getCondition = mainLock.newCondition();    public ProducerConsumerCondition() {        this(10);    }    public ProducerConsumerCondition(int bufSize) throws IllegalArgumentException{        this.bufSize = bufSize;        if(bufSize < 0) {            throw new IllegalArgumentException("bufSize can't less zero");        }        buf = new int[bufSize];    }    public void put(int v) throws InterruptedException{        mainLock.lock();        try {            while(currentSize >= bufSize) {                putCondition.await();            }            if(currentSize < bufSize) {                buf[currentSize++] = v;                getCondition.signal();            }        } catch(InterruptedException e) {             throw e;        } finally {            mainLock.unlock();        }    }    public int get() throws InterruptedException{        mainLock.lock();        try {            while(currentSize == 0) {                getCondition.await();            }            if(currentSize > 0) {                int temp = buf[currentSize - 1];                currentSize--;                putCondition.signal();                return temp;            }        } catch(InterruptedException e) {            throw e;        } finally {            mainLock.unlock();        }    }    @Override    public String toString() {        StringBuffer sb = new StringBuffer();        sb.append("[");        sb.append("queue's length=" + currentSize);        sb.append(" ");        for(int i = 0; i < currentSize - 1; i++) {            sb.append(buf[i] + ",");        }        if(currentSize > 0) {            sb.append(buf[currentSize - 1]);        }        sb.append("]");        return sb.toString();    }}

说明

1.从代码中可以看出使用ReentrantLock的一个缺点，就是每次lock完都必须要在finally块中执行unLock，而这个我们不是每时每刻都会记得的。

转载请注明原文地址：http://blog.csdn.net/u012619640/article/details/48090939