有界队列

有界队列

一种特殊的队列，当队列为空时，队列的获取将会阻塞获取线程，直到队列中有新增元素，当队列已满时，队列的插入操作将会阻塞插入线程，直到队列出现“空位”。

package com.mutithread.chapter5;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 有界队列：一种特殊的队列，当队列为空时，队列的获取将会阻塞获取线程，
 * 直到队列中有新增元素，当队列已满时，队列的插入操作将会阻塞插入线程，直到队列出现“空位”。
 * @param <T>
 */
public class BoundedQueue<T> {

    private Object[] items;

    //添加的下标，删除的下标和数组当前的数量
    private int addIndex,removeIndex,count;

    private Lock lock = new ReentrantLock();
    private Condition notEmpty = lock.newCondition();
    private Condition notFull = lock.newCondition();

    public BoundedQueue(int size){
        items = new Object[size];
    }

    //添加一个线程，若数组满，则添加线程进入等待状态，直到有"空位"
    public  void add(T t) throws InterruptedException {
        lock.lock();

        try{
           while(count == items.length){
               //若果一个线程调用了Condition.await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待队列
               notFull.await();
           }

           items[addIndex] = t;
           if(++addIndex == items.length)
               addIndex = 0;
            ++count;

            notEmpty.signal();
        }finally {
            lock.unlock();
        }
    }


    public T remove() throws  InterruptedException{

        lock.lock();

        try{
            while (count == 0)
                notEmpty.await();

            Object x = items[removeIndex];

            if(removeIndex == items.length)
                removeIndex = 0;

            --count;
            notFull.signal();

            return (T)x;
        }finally {
            lock.unlock();
        }
    }
}

Condition实现分析：
ConditionObject是AbstractQueuedSynchronizer的内部类，因为Condition的操作需要获取相关联的锁。每个Condition都包含一个队列（等待队列），该队列是Condition实现等待/通知的关键。