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

上一篇我们使用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