/** Main lock guarding all access */

    final ReentrantLock lock = new ReentrantLock();

    /** Condition for waiting takes */

    private final Condition notEmpty = lock.newCondition();

    /** Condition for waiting puts */

    private final Condition notFull = lock.newCondition();

/** 双向链表节点 */  
//ava里面static一般用来修饰成员变量或函数。但有一种特殊用法是用static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用，而不需实例一个外部类
//final说明不允许其他类来继承这个类

static final class Node<E> {

    /**

     * 元素值

     */

    E item;  

    /**

     * 节点前驱

     * 1.指向前驱；2.指向this，说明前驱是尾节点，看unlinklast；3.指向null说明没有前驱

     */

    Node<E> prev;  

    /**

     * 节点后继

     * 1.指向后继；2.指向this,说明后继是头结点，看unlinkfirst；3.指向null说明没有后继

     */

    Node<E> next;  

    Node(E x) {

        item = x;

    }

}  

    //first是双向链表的表头

    transient Node<E> first;  //不允许序列化 保证安全

    //last是双向链表的表尾

    transient Node<E> last;

    //count是LinkedBlockingDeque的实际大小，即双向链表中当前节点个数

    private transient int count;

    //是LinkedBlockingDeque的容量，它是在创建LinkedBlockingDeque时指定的

    private final int capacity;

    public LinkedBlockingDeque() {

        this(Integer.MAX_VALUE);

    }

    public LinkedBlockingDeque(int capacity) {

        if (capacity <= 0) throw new IllegalArgumentException();

        this.capacity = capacity;

    }

    public LinkedBlockingDeque(Collection<? extends E> c) {

        this(Integer.MAX_VALUE);

        final ReentrantLock lock = this.lock;

        lock.lock(); // Never contended, but necessary for visibility

        try {

            for (E e : c) {

                if (e == null)

                    throw new NullPointerException();

                if (!linkLast(new Node<E>(e)))

                    throw new IllegalStateException("Deque full");

            }

        } finally {

            lock.unlock();

        }

    }

    public void addFirst(E e) {

        if (!offerFirst(e))

            throw new IllegalStateException("Deque full");

    }

    public void addLast(E e) {

        if (!offerLast(e))

            throw new IllegalStateException("Deque full");

    }

    public boolean offerFirst(E e) {

        if (e == null) throw new NullPointerException();

        Node<E> node = new Node<E>(e);

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            return linkFirst(node);

        } finally {

            lock.unlock();

        }

    }

    public boolean offerLast(E e) {

        if (e == null) throw new NullPointerException();

        Node<E> node = new Node<E>(e);

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            return linkLast(node);

        } finally {

            lock.unlock();

        }

    }

    public void putFirst(E e) throws InterruptedException {

        if (e == null) throw new NullPointerException();

        Node<E> node = new Node<E>(e);

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            while (!linkFirst(node))

                notFull.await();

        } finally {

            lock.unlock();

        }

    }

    public void putLast(E e) throws InterruptedException {

        if (e == null) throw new NullPointerException();

        Node<E> node = new Node<E>(e);

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            while (!linkLast(node))

                notFull.await();

        } finally {

            lock.unlock();

        }

    }

/**

 * 设置node为链表头节点，链表满时为false

 */

private boolean linkFirst(Node<E> node) {

    // assert lock.isHeldByCurrentThread();

    if (count >= capacity) //超过容量false

        return false;

    Node<E> f = first;

    node.next = f; //新节点的next指向原first

    first = node; //设置node为新的first

    if (last == null) //没有尾节点，就将node设置成尾节点

        last = node;

    else

        f.prev = node; //有尾节点，那就将之前first的pre指向新增node

    ++count; //累加节点数量  //此处我在实现代码的过程中漏掉了

    notEmpty.signal(); //有新节点入队，通知非空条件队列

    return true;

}  

/**

 * 设置node为链表尾节点，链表满时为false

 */

private boolean linkLast(Node<E> node) {

    // assert lock.isHeldByCurrentThread();

    if (count >= capacity)

        return false;

    Node<E> l = last;

    node.prev = l;

    last = node;

    if (first == null) //为null，说明之前队列空吧，那就first也指向node

        first = node;

    else

        l.next = node; //非null，说明之前的last有值，就将之前的last的next指向node

    ++count;

    notEmpty.signal();

    return true;

}  

    public E removeFirst() {

        E x = pollFirst();

        if (x == null) throw new NoSuchElementException();

        return x;

    }

    public E removeLast() {

        E x = pollLast();

        if (x == null) throw new NoSuchElementException();

        return x;

    }

    public E pollFirst() {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            return unlinkFirst();

        } finally {

            lock.unlock();

        }

    }

    public E pollLast() {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            return unlinkLast();

        } finally {

            lock.unlock();

        }

    }

    public E takeFirst() throws InterruptedException {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            E x;

            while ( (x = unlinkFirst()) == null)

                notEmpty.await();

            return x;

        } finally {

            lock.unlock();

        }

    }

    public E takeLast() throws InterruptedException {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            E x;

            while ( (x = unlinkLast()) == null)

                notEmpty.await();

            return x;

        } finally {

            lock.unlock();

        }

    }
    

/**

 * 移除头结点，链表空返回null

 */

private E unlinkFirst() {

    // assert lock.isHeldByCurrentThread();

    Node<E> f = first;

    if (f == null)

        return null; //空返回null

    Node<E> n = f.next;

    E item = f.item;

    f.item = null;

    f.next = f; // help GC

    first = n;

    if (n == null) //说明之前应该只有一个节点，移除头结点后，链表空，现在first和last都指向null了

        last = null;

    else

        n.prev = null; //否则的话，n的pre原来指向之前的first，现在n变为first了，pre指向null

    --count;

    notFull.signal(); //通知非满条件队列

    return item;

}  

/**

 * 移除尾结点，链表空返回null

 */

private E unlinkLast() {

    // assert lock.isHeldByCurrentThread();

    Node<E> l = last;

    if (l == null)

        return null;

    Node<E> p = l.prev;

    E item = l.item;

    l.item = null;

    l.prev = l; // help GC

    last = p;

    if (p == null)

        first = null;

    else

        p.next = null;

    --count;

    notFull.signal();

    return item;

}  

/**

 * 移除指定节点：p--》x--》n

 */

void unlink(Node<E> x) {

    // assert lock.isHeldByCurrentThread();

    Node<E> p = x.prev;

    Node<E> n = x.next;

    if (p == null) { //prev为null说明x节点为头结点

        unlinkFirst();

    } else if (n == null) {

        unlinkLast(); //nex为null说明待清除节点为尾节点

    } else { //否则的话节点处于链表中间

        p.next = n; //将p和n互链

        n.prev = p;

        x.item = null;

        // 没有断开x节点链接，可能有其他线程在迭代链表

        --count;

        notFull.signal();

    }

} 

    public E peek() {

        return peekFirst();

    }

    public E peekFirst() {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            return (first == null) ? null : first.item;

        } finally {

            lock.unlock();

        }

    }

    //peekLast就不贴了

    public int size() {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            return count;

        } finally {

            lock.unlock();

        }

    }