//存儲的數(shù)據(jù) 存放在數(shù)組中
    final Object[] items;
    //讀數(shù)據(jù)位置
    int takeIndex;
    //寫入數(shù)據(jù)位置
    int putIndex;
    //數(shù)據(jù)數(shù)量
    int count;
    //隊列同步相關(guān)屬性
    final ReentrantLock lock;
    private final Condition notEmpty;
    private final Condition notFull;

 public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }
   //通過初始容量和是否公平性搶鎖標(biāo)志來進行實例化
    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }
    //通過初始容量capacity、公平性標(biāo)志fair和集合c
    public ArrayBlockingQueue(int capacity, boolean fair,Collection<? extends E> c) {
        this(capacity, fair);
        final ReentrantLock lock = this.lock;
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
            int i = 0;
            try {
                for (E e : c) {
                    //數(shù)據(jù)是不能為null
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }

 public void put(E e) throws InterruptedException {
        //檢測插入數(shù)據(jù)不能為null
        checkNotNull(e);
        //添加可中斷的鎖
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length) //容量滿了需要阻塞
                notFull.await();
            //當(dāng)前集合未滿，執(zhí)行插入操作
            insert(e);
        } finally {
            //釋放鎖
            lock.unlock();
        }
    }
    private void insert(E x) {
        items[putIndex] = x;
        putIndex = inc(putIndex);
        ++count;
        //通知take操作已經(jīng)有數(shù)據(jù)嗎，如果有take方法阻塞，此時可被喚醒來執(zhí)行take操作
        notEmpty.signal();
    }
  //循環(huán)數(shù)組的特殊標(biāo)志處理 ，如果是到最大值則重定向到0號索引
    final int inc(int i) {
        return (++i == items.length) ? 0 : i;
    }

    public E take() throws InterruptedException {
        //添加可中斷的鎖
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0) //隊列中沒有數(shù)據(jù)時，需要阻塞，直到有數(shù)據(jù)put進入隊列通知該操作可以繼續(xù)執(zhí)行
                notEmpty.await();
            //有數(shù)據(jù)時
            return extract();
        } finally {
            //釋放鎖
            lock.unlock();
        }
    }
    private E extract() {
        final Object[] items = this.items;
        E x = this.<E>cast(items[takeIndex]);
        items[takeIndex] = null;
        takeIndex = inc(takeIndex);
        --count;
        //發(fā)出通知 通知put方法，喚醒put操作
        notFull.signal();
        return x;
    }