//容量，如果沒有指定，該值為Integer.MAX_VALUE;
    private final int capacity;
    //當前隊列中的元素
    private final AtomicInteger count = new AtomicInteger();
    //隊列頭節(jié)點，始終滿足head.item==null
    transient Node<E> head;
    //隊列的尾節(jié)點，始終滿足last.next==null
    private transient Node<E> last;
    //用于出隊的鎖
    private final ReentrantLock takeLock = new ReentrantLock();
    //當隊列為空時，保存執(zhí)行出隊的線程
    private final Condition notEmpty = takeLock.newCondition();
    //用于入隊的鎖
    private final ReentrantLock putLock = new ReentrantLock();
    //當隊列滿時，保存執(zhí)行入隊的線程
    private final Condition notFull = putLock.newCondition();

 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);//last和head在隊列為空時都存在，所以隊列中至少有一個節(jié)點
    }
    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 {
        //不允許元素為null
        if (e == null) throw new NullPointerException();
        int c = -1;
        //以當前元素新建一個節(jié)點
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        //獲得入隊的鎖
        putLock.lockInterruptibly();
        try {
            //如果隊列已滿，那么將該線程加入到Condition的等待隊列中
            while (count.get() == capacity) {
                notFull.await();
            }
            //將節(jié)點入隊
            enqueue(node);
            //得到插入之前隊列的元素個數(shù)
            c = count.getAndIncrement();
            //如果還可以插入元素，那么釋放等待的入隊線程
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            //解鎖
            putLock.unlock();
        }
        //通知出隊線程隊列非空
        if (c == 0)
            signalNotEmpty();
    }

 private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        //獲取takeLock
        takeLock.lock();
        try {
            //釋放notEmpty條件隊列中的第一個等待線程
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }

public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        //獲取takeLock鎖
        takeLock.lockInterruptibly();
        try {
            //如果隊列為空，那么加入到notEmpty條件的等待隊列中
            while (count.get() == 0) {
                notEmpty.await();
            }
            //得到隊頭元素
            x = dequeue();
            //得到取走一個元素之前隊列的元素個數(shù)
            c = count.getAndDecrement();
            //如果隊列中還有數(shù)據(jù)可取，釋放notEmpty條件等待隊列中的第一個線程
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        //如果隊列中的元素從滿到非滿，通知put線程
        if (c == capacity)
            signalNotFull();
        return x;
    }

private E dequeue() {
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }

 public boolean remove(Object o) {
        //因為隊列不包含null元素，返回false
        if (o == null) return false;
        //獲取兩把鎖
        fullyLock();
        try {
            //從頭的下一個節(jié)點開始遍歷
            for (Node<E> trail = head, p = trail.next;
                 p != null;
                 trail = p, p = p.next) {
                 //如果匹配，那么將節(jié)點從隊列中移除，trail表示前驅(qū)節(jié)點
                if (o.equals(p.item)) {
                    unlink(p, trail);
                    return true;
                }
            }
            return false;
        } finally {
            //釋放兩把鎖
            fullyUnlock();
        }
    }

public int size() {
        return count.get();
    }