快速掌握并发编程---ArrayBlockingQueue 底层原理和实战

//创造一个队列，指定队列容量就可以了，默认模式为非公平模式
public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
}
////创造一个队列，指定队列容量和指定公平性
public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        //这里用的就是重入锁，
        //公平性通过fair来判断
        lock = new ReentrantLock(fair);
        //不为空条件队列，明显就是给消费者用
        notEmpty = lock.newCondition();
        //没有满条件队列，给生产者用
        notFull =  lock.newCondition();
}

//底层数据结构，说明底层存储数据的数据结构是数组
private final E[] items;
//用来为下一个take/poll/remove的索引（出队）
private int takeIndex;
//用来为下一个put/offer/add的索引（入队）
private int putIndex;
//队列中元素的个数
private int count;
/** Main lock guarding all access */   
private final ReentrantLock lock;//锁
/** Condition for waiting takes */
private final Condition notEmpty;//等待出队的条件
/** Condition for waiting puts */
private final Condition notFull;//等待入队的条件

public boolean add(E e) {
    // 调用父类的add(e)方法
    return super.add(e);
}

public boolean add(E e) {
    // 调用offer(e)如果成功返回true，如果失败抛出异常
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

/**
 * 在队尾插入一个元素，
 * 如果队列没满，立即返回true；
 * 如果队列满了，立即返回false
 * 注意：该方法通常优于add(),因为add()失败直接抛异常
 */
public boolean offer(E e) {
    //检查存入的数据是否为null
    checkNotNull(e);        
    final ReentrantLock lock = this.lock;
    lock.lock();        
    try {            
        //如果数组满了，返回入队失败            
        if (count == items.length)                
            return false;            
        else {                
            //入队                
            enqueue(e);                
            return true;            
        }        
    } finally {            
        lock.unlock();        
    }
}
//如果存入的数据是null的会抛控指针异常    
private static void checkNotNull(Object v) {        
    if (v == null)   throw new NullPointerException();    
}
//putIndex是int类型，默认值就是0
private void enqueue(E x) {        
    final Object[] items = this.items;        
    //从下标为0的位置开始放入数据        
    items[putIndex] = x;        
    //如果putIndex等于数组大小，证明这是最后一个能存放的，然后把putIndex设置为0        
    //否则++putIndex        
    if (++putIndex == items.length){            
        putIndex = 0;        
    }
    //放入数据个数+1
    count++;
     /**
      * 唤醒一个线程
      * 如果有任意一个线程正在等待这个条件，那么选中其中的一个区唤醒。
      * 在从等待状态被唤醒之前，被选中的线程必须重新获得锁
      */
    notEmpty.signal();
}

public void put(E e) throws InterruptedException {        
    checkNotNull(e);        
    final ReentrantLock lock = this.lock;  
    //加锁，如果线程中断了抛出异常
    lock.lockInterruptibly();        
    try {            
        while (count == items.length){   
            //这里就是阻塞了，要注意。如果运行到这里，
            //那么它会释放上面的锁，一直等到唤醒
            notFull.await();      
        }    
        //放入队列
        enqueue(e);        
    } finally {            
        lock.unlock();        
    }
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    //加锁，如果线程中断了抛出异常
    lock.lockInterruptibly();        
    try {
        //队列中不存元素
        while (count == 0){  
            /*
             * 一直等待条件notEmpty，即被其他线程唤醒
             * （唤醒其实就是，有线程将一个元素入队了，然后调用notEmpty.signal()
             * 唤醒其他等待这个条件的线程，同时队列也不空了）
             */
            notEmpty.await();
        }
        //否则出队
        return dequeue();        
    } finally {            
        lock.unlock();        
    }    
}
private E dequeue() {
    final Object[] items = this.items;
    // 取取指针位置的元素
    E x = (E) items[takeIndex];
    // 把取指针位置设为null
    items[takeIndex] = null;
    // 取指针前移，如果数组到头了就返回数组前端循环利用
    if (++takeIndex == items.length)
        takeIndex = 0;
    // 元素数量减1
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    // 唤醒notFull条件
    notFull.signal();
    return x;
}

public E poll() {        
    final ReentrantLock lock = this.lock;        
    lock.lock();        
    try {
        //如果队列里没有数据就直接返回null
        //否则从队列头部出队
        return (count == 0) ? null : dequeue();        
    } finally {            
        lock.unlock();       
    }   
}

public E remove() {
    // 调用poll()方法出队
    E x = poll();
    if (x != null)
        // 如果有元素出队就返回这个元素
        return x;
    else
        // 如果没有元素出队就抛出异常
        throw new NoSuchElementException();
}