LinkedBlockingDeque基于双向链表实现的阻塞队列，根据构造传入的容量大小决定有界还是无界，默认不传的话，大小Integer.Max。

实现BlockingDequeue接口，这个接口继承BlockingQueue和Dequeue，看下接口方法：

public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
	/** Deque 方法 */
    /**
     * 插入元素到队列头，队列满就IllegalStateException异常
     */
    void addFirst(E e);

    /**
     * 插入元素到队列尾，队列满就IllegalStateException异常
     */
    void addLast(E e);

    /**
     * 插入元素到队列头，队列满就false
     */
    boolean offerFirst(E e);

    /**
     * 插入元素到队列尾，队列满就false
     */
    boolean offerLast(E e);

    /**
     * 上面的几个插入方法，如果插入时队列满就返回异常或false，这里put操作加入条件队列wait
     */
    void putFirst(E e) throws InterruptedException;

    /**
     * 插入元素到队列尾，队列满就加入条件队列wait
     */
    void putLast(E e) throws InterruptedException;

    /**
     * 响应超时的offer插入队列头
     */
    boolean offerFirst(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 响应超时的offer插入队列尾
     */
    boolean offerLast(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 获取队列头，队列不可用就wait
     */
    E takeFirst() throws InterruptedException;

    /**
     * 获取队列尾，队列不可用就wait
     */
    E takeLast() throws InterruptedException;

    /**
     * 响应超时的获取队列头
     */
    E pollFirst(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 响应超时的获取队列尾
     */
    E pollLast(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 删除第一个匹配的指定元素
     */
    boolean removeFirstOccurrence(Object o);

    /**
     * 删除最后一个匹配的指定元素
     */
    boolean removeLastOccurrence(Object o);

    // *** BlockingQueue methods 之前看过***
    
    boolean add(E e);

    boolean offer(E e);

    void put(E e) throws InterruptedException;

    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    E remove();
 
    E poll();

    E take() throws InterruptedException;

    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 获取队列头，跟peek不同的是，队列空，抛异常
     */
    E element();
    
    E peek();

    boolean remove(Object o);

    public boolean contains(Object o);

    public int size();

    Iterator<E> iterator();

    // *** Stack methods ***

    /**
     * addFirst
     */
    void push(E e);
}

因为是双向结构，所以基本的操作成对的XXXFirst，XXXLast。

/** 双向链表节点 */
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;
    }
}

/**
 * 首节点
 */
transient Node<E> first;

/**
 * 尾节点
 */
transient Node<E> last;

/** 队列元素个数 */
private transient int count;

/** 队列容量 */
private final int capacity;

/** Main lock guarding all access */
final ReentrantLock lock = new ReentrantLock();

/** 获取的条件等待：非空条件 */
private final Condition notEmpty = lock.newCondition();

/** 插入元素的条件等待：非满条件 */
private final Condition notFull = lock.newCondition();

/**
 * 空构造，默认容量最大
 */
public LinkedBlockingDeque() {
    this(Integer.MAX_VALUE);
}

/**
 * 指定容量
 */
public LinkedBlockingDeque(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
}

构造的时候可以传入链表容量大小，没传入就Integer.MAX。

看下最基础的几个方法：

// 4个基础方法，Dequeue的操作基本都是调用这些
/**
 * 设置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;
}

/**
 * 移除头结点，链表空返回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();
    }
}

大部分的Deque的实现都是调用这几个方法。因为是双端队列，所以link\unlink都有针对first和last的操作。看明白这几个方法，其他方法应该都没问题了。