LinkedBlockingDeque 使用笔记

た入场券 2022-02-25 10:26 143阅读 0赞

**原理**：双向链表实现的双向并发阻塞队列，该阻塞队列同时支持FIFO和FILO两种操作方式，即可以从队列的头和尾同时操作(插入/删除)；并且，该阻塞队列是支持线程安全。

**特性**：若某线程(线程A)要取出数据时，队列正好为空，则该线程会执行notEmpty.await()进行等待；当其它某个线程(线程B)向队列中插入了数据之后，会调用notEmpty.signal()唤醒“notEmpty上的等待线程”。此时，线程A会被唤醒从而得以继续运行。 此外，线程A在执行取操作前，会获取takeLock，在取操作执行完毕再释放takeLock。  
若某线程(线程H)要插入数据时，队列已满，则该线程会它执行notFull.await()进行等待；当其它某个线程(线程I)取出数据之后，会调用notFull.signal()唤醒“notFull上的等待线程”。此时，线程H就会被唤醒从而得以继续运行。 此外，线程H在执行插入操作前，会获取putLock，在插入操作执行完毕才释放putLock。

**1、 take函数的用法**  
定义：获取并移除此双端队列的第一个元素，必要时将一直等待可用元素  
poll函数的定义：获取并移除此双端队列表示的队列的头部（即此双端队列的第一个元素），必要时将在指定的等待时间内等待可用元素  
源码

// take()
    public E take() throws InterruptedException { 
          return takeFirst();
    }
    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();
        }
    }
    
    //pull()
    public E poll() { 
        return pollFirst();
    }
    public E pollFirst() { 
        final ReentrantLock lock = this.lock;
        lock.lock();
        try { 
            return unlinkFirst();
        } finally { 
            lock.unlock();
        }
    }
    
    
    private E unlinkFirst() { 
        Node<E> f = first;
        if (f == null)
            return null;
        Node<E> n = f.next;
        E item = f.item;
        f.item = null;
        f.next = f; // help GC
        first = n;
        if (n == null)
            last = null;
        else
            n.prev = null;
        --count;
        // 唤醒处于阻塞插入的线程
        notFull.signal();
        return item;
    }

take()返回的结果确保不会是Null，而poll()没有这样的保证，如果在队列为空的情况下，take()会阻塞掉，而poll()会返回Null。

**2、offer函数的用法**  
将指定的元素插入此双端队列表示的队列中（即此双端队列的尾部），必要时将在指定的等待时间内一直等待可用空间

public boolean offer(E e) { 
        return offerLast(e);
    }
    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();
        }
    }
    
    private boolean linkLast(Node<E> node) { 
        if (count >= capacity)
            return false;
        Node<E> l = last;
        node.prev = l;
        last = node;
        if (first == null)
            first = node;
        else
            l.next = node;
        // 将“节点数量”+1
        ++count;
        // 插入节点之后，唤醒notEmpty上的等待线程。
        notEmpty.signal();
        return true;
    }
    //linkLast()的作用，是将节点插入到双向队列的末尾；插入节点之后，唤醒notEmpty上的等待线程。

**3、使用**

private final BlockingQueue<Runnable> taskQueue = new LinkedBlockingDeque<>();