BlockingDeque&BlockingQueue区别

1.BlockingQueue阻塞队列,FIFO一端进入队列，一端出队列

  BlockingQueue，进出口单一明确。队列尾部进入队列，队列头部出队列。FIFO

2.BlockingDequeu 双端阻塞队列，两端都可以进队列，也可以出队列

  putFirst-> 队列头部进入队列

  takeFirst -> 队列头部出队列

  putLast -> 队列尾部进入队列

  takeLast -> 队列尾部出队列

  public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E>

  双端阻塞队列，继承了FIFO特性，又继承了双端队列特性

  

3.BlockingDeque实现类只有链表方式的实现类LinkedBlockinbgDeque,没有数组Array方式的实现类

  1)LinkedBlockingDeque无指定capacity大小，Integer.MaxVal为默认值大小

  2) 

    /**
     * @throws NullPointerException {@inheritDoc}
     * @throws InterruptedException {@inheritDoc}
     */
    public void putFirst(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            while (!linkFirst(e)) //如果Deque已经full状态了，那么呈阻塞状态
                notFull.await();
        } finally {
            lock.unlock();
        }

    }

   /**      //如果count > capacity那么插入失败
     * Links e as first element, or returns false if full.
     */
    private boolean linkFirst(E e) {
        // assert lock.isHeldByCurrentThread();
        if (count >= capacity)
            return false;
        Node<E> f = first;     //插入队列头部
        Node<E> x = new Node<E>(e, null, f);
        first = x;
        if (last == null)
            last = x;
        else
            f.prev = x;
        ++count;
        notEmpty.signal();
        return true;
    }

4.LinkedBlockingDeque源代码测试实例

   for(int i = 0;i < 10;i++){
try {
mDeQueue.putFirst(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
  }


  for(int i = 0;i < 12;i++){
Thread thread = new Thread("tName-"+i){
@Override
public void run() {
super.run();
try {
System.out.println("tName->" + getName() + " waiting for...");
int r = mDeQueue.takeFirst();
System.out.println("tName->" + getName() + " take -> " + r + " succ");
     } catch (InterruptedException e) {
e.printStackTrace();
    }
          }
};
thread.start();
}

0-10依次插入到双端队列的头部，排序顺序9,8,7...0  12个线程从头部获取，依次的顺序9,8,7....0 剩下的两个线程呈现阻塞状态，等待队列可以插入的状态。所以thread-10，thread-11都呈现waitingfor，阻塞状态中.

输出结果:

tName->tName-0 waiting for...
tName->tName-1 waiting for...
tName->tName-0 take -> 9 succ
tName->tName-3 waiting for...
tName->tName-4 waiting for...
tName->tName-4 take -> 6 succ
tName->tName-6 waiting for...
tName->tName-6 take -> 5 succ
tName->tName-2 waiting for...
tName->tName-2 take -> 4 succ
tName->tName-1 take -> 8 succ
tName->tName-8 waiting for...
tName->tName-8 take -> 3 succ
tName->tName-5 waiting for...
tName->tName-3 take -> 7 succ
tName->tName-5 take -> 2 succ
tName->tName-7 waiting for...
tName->tName-7 take -> 1 succ
tName->tName-9 waiting for...
tName->tName-11 waiting for...
tName->tName-10 waiting for...
tName->tName-9 take -> 0 succ