/** 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();
        }
    }