// 第一個(gè)	
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) {
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }

	// 第二個(gè)
    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();
    }

	// 第三個(gè)
	public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

public void put(E e) throws InterruptedException {
         // 檢查元素是否為null
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        // 獲取鎖
        lock.lockInterruptibly();
        try {
            // 如果當(dāng)前隊(duì)列為空，變?yōu)樽枞麪顟B(tài)
            while (count == items.length)
                notFull.await();
            // 反之，就添加元素
            enqueue(e);
        } finally {
            // 解鎖
            lock.unlock();
        }
    }

    private void enqueue(E x) {
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        // 此時(shí)隊(duì)列不為空，喚醒消費(fèi)者
        notEmpty.signal();
    }

 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        // 獲取鎖
        lock.lockInterruptibly();
        try {
            // 如果隊(duì)列為空，消費(fèi)者變?yōu)樽枞麪顟B(tài)
            while (count == 0)
                notEmpty.await();
            // 不為空，就獲取數(shù)據(jù)
            return dequeue();
        } finally {
            // 解鎖
            lock.unlock();
        }
    }

        private E dequeue() {
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        // 獲取隊(duì)頭元素x
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
         // 此時(shí)隊(duì)列沒有滿，同時(shí)生產(chǎn)者繼續(xù)添加數(shù)據(jù)
        notFull.signal();
        return x;
    }

// 不指定容量     
	public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }
	// 指定容量
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }

	// 等同于合并數(shù)組
    public LinkedBlockingQueue(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
        final ReentrantLock putLock = this.putLock;
        putLock.lock(); // Never contended, but necessary for visibility
        try {
            int n = 0;
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
                enqueue(new Node<E>(e));
                ++n;
            }
            count.set(n);
        } finally {
            putLock.unlock();
        }
    }

 public void put(E e) throws InterruptedException {
        // 元素為空，拋出異常
        if (e == null) throw new NullPointerException();
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        // 獲取隊(duì)列中的數(shù)據(jù)量
        final AtomicInteger count = this.count;
        // 獲取鎖
        putLock.lockInterruptibly();
        try {
            // 隊(duì)列滿了，變?yōu)樽枞麪顟B(tài)
            while (count.get() == capacity) {
                notFull.await();
            }
            // 將目標(biāo)元素添加到鏈表的尾端
            enqueue(node);
            // 總數(shù)增加
            c = count.getAndIncrement();
            // 隊(duì)列還沒有滿，繼續(xù)添加元素
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            // 解鎖
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }

public E take() throws InterruptedException {
        E x;
        int c = -1;
        // 獲取隊(duì)列中的工作數(shù)
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        // 獲取鎖
        takeLock.lockInterruptibly();
        try {
            // 如果隊(duì)列為空，變?yōu)樽枞麪顟B(tài)
            while (count.get() == 0) {
                notEmpty.await();
            }
            // 獲取隊(duì)頭元素
            x = dequeue();
            // 遞減
            c = count.getAndDecrement();
            // 通知消費(fèi)者
            if (c > 1)
                notEmpty.signal();
        } finally {
            // 解鎖
            takeLock.unlock();
        }
        if (c == capacity)
            // 
            signalNotFull();
        return x;
    }

public class BlockQueue {
    // 對(duì)象鎖
    public static final Object LOCK = new Object();
    // 控制變量的值 來通知雙方
    public boolean condition;
    
    public void put() {
        synchronized (LOCK) {
            while (condition) {
                try {
                    // 滿了
                    System.out.println("put   隊(duì)列滿了，開始阻塞");
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            condition = true;
            System.out.println("put   改為true，喚醒消費(fèi)者");
            LOCK.notifyAll();
        }
    }


    public void take() {
        synchronized (LOCK) {
            while (!condition) {
                // 沒滿
                System.out.println("take   隊(duì)列沒滿，開始阻塞");
                try {
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            condition = false;
            System.out.println("take   改為false，喚醒生產(chǎn)者");
            LOCK.notifyAll();
        }
    }
}