【死磕Java并发】-----J.U.C之阻塞队列:LinkedBlockingDeque

原创 2017年10月03日 15:49:33

原文出处http://cmsblogs.com/chenssy

前面的BlockingQueue都是单向的FIFO队列,而LinkedBlockingDeque则是一个由链表组成的双向阻塞队列,双向队列就意味着可以从对头、对尾两端插入和移除元素,同样意味着LinkedBlockingDeque支持FIFO、FILO两种操作方式。

LinkedBlockingDeque是可选容量的,在初始化时可以设置容量防止其过度膨胀,如果不设置,默认容量大小为Integer.MAX_VALUE。

LinkedBlockingDeque

LinkedBlockingDeque 继承AbstractQueue,实现接口BlockingDeque,而BlockingDeque又继承接口BlockingQueue,BlockingDeque是支持两个附加操作的 Queue,这两个操作是:获取元素时等待双端队列变为非空;存储元素时等待双端队列中的空间变得可用。这两类操作就为LinkedBlockingDeque 的双向操作Queue提供了可能。BlockingDeque接口提供了一系列的以First和Last结尾的方法,如addFirst、addLast、peekFirst、peekLast。

public class LinkedBlockingDeque<E>
    extends AbstractQueue<E>
    implements BlockingDeque<E>, java.io.Serializable {

    // 双向链表的表头
    transient Node<E> first;

    // 双向链表的表尾
    transient Node<E> last;

    // 大小,双向链表中当前节点个数
    private transient int count;

    // 容量,在创建LinkedBlockingDeque时指定的
    private final int capacity;

    final ReentrantLock lock = new ReentrantLock();

    private final Condition notEmpty = lock.newCondition();

    private final Condition notFull = lock.newCondition();

}

通过上面的Lock可以看出,LinkedBlockingDeque底层实现机制与LinkedBlockingQueue一样,依然是通过互斥锁ReentrantLock 来实现,notEmpty 、notFull 两个Condition做协调生产者、消费者问题。

与其他BlockingQueue一样,节点还是使用内部类Node:

    static final class Node<E> {
        E item;

        Node<E> prev;

        Node<E> next;

        Node(E x) {
            item = x;
        }
    }

双向嘛,节点肯定得要有前驱prev、后继next咯。

基础方法

LinkedBlockingDeque 的add、put、offer、take、peek、poll系列方法都是通过调用XXXFirst,XXXLast方法。所以这里就仅以putFirst、putLast、pollFirst、pollLast分析下。

putFirst

putFirst(E e) :将指定的元素插入此双端队列的开头,必要时将一直等待可用空间。

    public void putFirst(E e) throws InterruptedException {
        // check null
        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条件上等待,直到被唤醒或中断
                notFull.await();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

先获取锁,然后调用linkFirst方法入列,最后释放锁。如果队列是满的则在notFull上面等待。linkFirst设置Node为对头:

    private boolean linkFirst(Node<E> node) {
        // 超出容量
        if (count >= capacity)
            return false;

        // 首节点
        Node<E> f = first;
        // 新节点的next指向原first
        node.next = f;
        // 设置node为新的first
        first = node;

        // 没有尾节点,设置node为尾节点
        if (last == null)
            last = node;
        // 有尾节点,那就将之前first的pre指向新增node
        else
            f.prev = node;
        ++count;
        // 唤醒notEmpty
        notEmpty.signal();
        return true;
    }

linkFirst主要是设置node节点队列的列头节点,成功返回true,如果队列满了返回false。整个过程还是比较简单的。

putLast

putLast(E e) :将指定的元素插入此双端队列的末尾,必要时将一直等待可用空间。

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

调用linkLast将节点Node链接到队列尾部:

    private boolean linkLast(Node<E> node) {
        if (count >= capacity)
            return false;
        // 尾节点
        Node<E> l = last;

        // 将Node的前驱指向原本的last
        node.prev = l;

        // 将node设置为last
        last = node;
        // 首节点为null,则设置node为first
        if (first == null)
            first = node;
        else
        //非null,说明之前的last有值,就将之前的last的next指向node
            l.next = node;
        ++count;
        notEmpty.signal();
        return true;
    }

pollFirst

pollFirst():获取并移除此双端队列的第一个元素;如果此双端队列为空,则返回 null。

    public E pollFirst() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return unlinkFirst();
        } finally {
            lock.unlock();
        }
    }

调用unlinkFirst移除队列首元素:

    private E unlinkFirst() {
        // 首节点
        Node<E> f = first;

        // 空队列,直接返回null
        if (f == null)
            return null;

        // first.next
        Node<E> n = f.next;

        // 节点item
        E item = f.item;

        // 移除掉first ==> first = first.next
        f.item = null;
        f.next = f; // help GC
        first = n;

        // 移除后为空队列,仅有一个节点
        if (n == null)
            last = null;
        else
        // n的pre原来指向之前的first,现在n变为first了,pre指向null
            n.prev = null;
        --count;
        notFull.signal();
        return item;
    }

pollLast

pollLast():获取并移除此双端队列的最后一个元素;如果此双端队列为空,则返回 null。

    public E pollLast() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return unlinkLast();
        } finally {
            lock.unlock();
        }
    }

调用unlinkLast移除尾结点,链表空返回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;
    }

LinkedBlockingDeque大部分方法都是通过linkFirst、linkLast、unlinkFirst、unlinkLast这四个方法来实现的,因为是双向队列,所以他们都是针对first、last的操作,看懂这个整个LinkedBlockingDeque就不难了。

掌握了双向队列的插入、删除操作,LinkedBlockingDeque就没有任何难度可言了,数据结构的重要性啊!!!!


欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!

–— Java成神之路: 488391811(一起走向Java成神) –—
这里写图片描述

版权声明:版权声明:转载前请留言获得作者许可,转载后标明作者 chenssy 和原文出处。原创不易,感谢您的支持 https://blog.csdn.net/chenssy/article/details/78155006

【死磕Java并发】-----J.U.C之阻塞队列:DelayQueue

原文出处http://cmsblogs.com/ 『chenssy』 DelayQueue是一个支持延时获取元素的无界阻塞队列。里面的元素全部都是“可延期”的元素,列头的元素是最先“到期”的元素,如果...
  • chenssy
  • chenssy
  • 2017-08-14 21:49:07
  • 4415

【死磕Java并发】-----J.U.C之Condition

此篇博客所有源码均来自JDK 1.8 在没有Lock之前,我们使用synchronized来控制同步,配合Object的wait()、notify()系列方法可以实现等待/通知模式。在Java SE5...
  • chenssy
  • chenssy
  • 2017-04-05 18:21:53
  • 6226

【死磕Java并发】-----J.U.C之Java并发容器:ConcurrentLinkedQueue

原文出处http://cmsblogs.com/ 『chenssy』 要实现一个线程安全的队列有两种方式:阻塞和非阻塞。阻塞队列无非就是锁的应用,而非阻塞则是CAS算法的应用。下面我们就开始一个非阻塞...
  • chenssy
  • chenssy
  • 2017-07-08 21:26:10
  • 6709

【死磕Java并发】-----J.U.C之AQS:AQS简介

Java的内置锁一直都是备受争议的,在JDK 1.6之前,synchronized这个重量级锁其性能一直都是较为低下,虽然在1.6后,进行大量的锁优化策略(【死磕Java并发】—–深入分析synchr...
  • chenssy
  • chenssy
  • 2017-03-05 22:26:36
  • 7027

【死磕Java并发】-----深入分析synchronized的实现原理

记得刚刚开始学习Java的时候,一遇到多线程情况就是synchronized,相对于当时的我们来说synchronized是这么的神奇而又强大,那个时候我们赋予它一个名字“同步”,也成为了我们解决多线...
  • chenssy
  • chenssy
  • 2017-02-05 21:48:08
  • 19134

【死磕Java并发】----深入分析CAS

CAS,Compare And Swap,即比较并交换。Doug lea大神在同步组件中大量使用CAS技术鬼斧神工地实现了Java多线程的并发操作。整个AQS同步组件、Atomic原子类操作等等都是以...
  • chenssy
  • chenssy
  • 2017-04-07 20:08:04
  • 7188

【死磕Java并发】-----J.U.C之AQS:CLH同步队列

此篇博客所有源码均来自JDK 1.8 在上篇博客【死磕Java并发】—–J.U.C之AQS:AQS简介中提到了AQS内部维护着一个FIFO队列,该队列就是CLH同步队列。CLH同步队列是一个FIFO双...
  • chenssy
  • chenssy
  • 2017-03-07 22:11:14
  • 5697

【死磕Java并发】-----J.U.C之并发工具类:Exchanger

此篇博客所有源码均来自JDK 1.8 前面三篇博客分别介绍了CyclicBarrier、CountDownLatch、Semaphore,现在介绍并发工具类中的最后一个Exchange。Exchang...
  • chenssy
  • chenssy
  • 2017-05-19 17:54:30
  • 5376

【死磕Java并发】-----Java内存模型之分析volatile

前篇博客【死磕Java并发】—–深入分析volatile的实现原理 中已经阐述了volatile的特性了: volatile可见性;对一个volatile的读,总可以看到对这个变量最终的写; vola...
  • chenssy
  • chenssy
  • 2017-02-23 20:27:42
  • 3344

Java并发包:双端阻塞队列(BlockingDeque)

BlockingDequeJava.util.concruuent包中的BlockingDeque接口是一种双端队列,向其中加入元素或从中取出元素都是线程安全的。这里展示如何使用BlockingDeq...
  • zxc123e
  • zxc123e
  • 2016-07-06 17:35:25
  • 6604
收藏助手
不良信息举报
您举报文章:【死磕Java并发】-----J.U.C之阻塞队列:LinkedBlockingDeque
举报原因:
原因补充:

(最多只允许输入30个字)