Java8 LinkedBlockingDeque 源码解析

最新推荐文章于 2024-07-23 07:30:00 发布
最新推荐文章于 2024-07-23 07:30:00 发布
阅读量678 收藏
点赞数
分类专栏： java8并发工具类源码解析 文章标签： BlockingDeque
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31865983/article/details/105498600
版权

  目录

1、定义

2、构造方法

 3、add / offer / put

4、poll / take / peek 

5、remove / clear /drainTo

6、push / pop

7、iterator / descendingIterator

      LinkedBlockingDeque表示一个可选固定容量的，线程安全的、基于链表和ReentrantLock实现的双端队列，即可以从队列头或者队列尾添加或者移除元素，本篇博客就详细探讨该类的实现。

1、定义

     LinkedBlockingDeque的类继承关系如下：

BlockingDeque继承自BlockingQueue和Deque，包含的方法如下：

 

后面会详细介绍各方法的用途。该类包含的实例属性如下：

    //第一个节点
    transient Node<E> first;

    //最后一个节点
    transient Node<E> last;

    //队列中包含的元素个数
    private transient int count;

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

    //同步锁
    final ReentrantLock lock = new ReentrantLock();

    //如果队列是空的，则在此Condition上等待
    private final Condition notEmpty = lock.newCondition();

    //如果队列是满的，则在此Condition上等待
    private final Condition notFull = lock.newCondition();

Node是一个静态内部类，表示队列中的一个节点，其定义如下：

prev和next就是该节点的前后节点了，用于构成一条双向链表。

2、构造方法

     同LinkedBlockingQueue，容量是可选的，如果不指定容量，则容量默认是int的最大值

 
//无固定容量时，默认容量为int的最大值
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(); //加锁和解锁会保证修改对其他CPU可见
        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();
        }
    }

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)
            first = node; //链表为空，node为第一个节点
        else
            l.next = node;
        ++count;
        //唤醒因为队列是空的而等待的线程
        notEmpty.signal();
        return true;
    }

 3、add / offer / put

       add系列有三个，add，addLast和addFirst，add的实现就是addLast，三个方法都是插入一个元素，如果满了返回false，不等待，否则返回true，addLast是插入到链表末尾，addFirst是插入到链表头。addLast和addFirst的实现就是调用不带时间参数的对应offerLast和offerFirst方法。

      put系列也有三个，put，putFirst和putLast，put的实现就是putLast；put类方法都是往链表中插入，如果队列满了则无期限等待直到被中断或者插入成功为止，其中putFirst是插入到链表头，putLast是插入到链表尾。

    offer系列有6个，offer、offerFirst、offerLast，offer的实现就是offerLast，这三个方法每个都有一个可以指定等待时间的重载版本，不带时间参数的版本不会阻塞，如果满了返回false，否则插入成功返回true；带时间参数的版本会阻塞指定的时间，如果超时则返回false，如果被中断了则抛出异常，插入成功返回true，其中offerFirst插入到链表头，offerLast插入到链表尾。具体实现如下：

public boolean add(E e) {
        addLast(e);
        return true;
    }

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 offer(E e) {
        return offerLast(e);
    }

public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {
        return offerLast(e, timeout, unit);
    }

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 offerFirst(E e, long timeout, TimeUnit unit)
        throws InterruptedException {
        if (e == null) throw new NullPointerException();
        Node<E> node = new Node<E>(e);
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (!linkFirst(node)) { //如果链表是满的则等待
                if (nanos <= 0) //等待超时返回false
                    return false;
                nanos = notFull.awaitNanos(nanos);
            }
            //插入成功返回true
            return true;
        } 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 boolean offerLast(E e, long timeout, TimeUnit unit)
        throws InterruptedException {
        if (e == null) throw new NullPointerException();
        Node<E> node = new Node<E>(e);
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (!linkLast(node)) { //链表满了，等待
                if (nanos <= 0)
                    return false; //等待超时
                nanos = notFull.awaitNanos(nanos);
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

public void put(E e) throws InterruptedException {
        putLast(e);
    }

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



private boolean linkFirst(Node<E> node) {
        // assert lock.isHeldByCurrentThread();
        if (count >= capacity) //容量达到上限，返回false
            return false;
        Node<E> f = first;
        node.next = f;
        first = node;
        if (last == null)
            last = node; //链表未初始化，first和last指向同一个节点
        else
            f.prev = node; //插入到原first节点的前面
        //队列元素个数加1    
        ++count;
        //唤醒因为队列是空的而阻塞的线程
        notEmpty.signal();
        return true;
    }

4、poll / take / peek 

     peek方法同add方法相对，同样有三个，peek、peekFirst和peekLast，peek的实现就是peekFirst，peekFirst返回链表头的元素，peekLast返回链表尾的元素，如果链表为空则返回null，不需要等待，也不需要将链表头或者链表尾节点移除。

     poll方法同offer方法相对，同样有六个，poll、pollFirst和pollLast，poll的实现是pollFirst，pollFirst移除链表头并返回链表头的元素，pollLast移除链表尾并返回链表尾的元素，如果链表为空则直接返回null，不需要等待；这三个方法都有一个带时间参数的重载版本，如果链表为空则必须要等待指定的时间，如果超时了返回null，如果等待期间被中断则抛出异常，如果链表不为空则移除链表头或者链表尾并返回关联的元素。

    take方法同put方法相对，同样有三个，take、takeFirst和takeLast，take的实现就是takeFirst，takeFirst移除链表头并返回链表头的元素，takeLast移除链表尾并返回链表尾的元素，如果链表为空则无期限等待直到链表不为空成功获取链表头或者链表尾的元素为止，如果被中断则抛出异常。具体实现如下：

public E peek() {
        return peekFirst();
    }

public E peekFirst() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //如果链表为空返回null，否则返回first节点的元素
            return (first == null) ? null : first.item;
        } finally {
            lock.unlock();
        }
    }

public E peekLast() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
             //如果链表为空返回null，否则返回last节点的元素
            return (last == null) ? null : last.item;
        } finally {
            lock.unlock();
        }
    }

public E poll() {
        return pollFirst();
    }

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        return pollFirst(timeout, unit);
    }

public E pollFirst() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //移除并返回链表头，如果链表为空则返回null
            return unlinkFirst();
        } finally {
            lock.unlock();
        }
    }

public E pollFirst(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            E x;
            while ( (x = unlinkFirst()) == null) { //链表为空则等待指定的时间
                if (nanos <= 0)
                    return null; //等待超时返回null
                nanos = notEmpty.awaitNanos(nanos);
            }
            return x;
        } finally {
            lock.unlock();
        }
    }

public E pollLast() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //移除并返回链表尾，如果链表为空则返回null
            return unlinkLast();
        } finally {
            lock.unlock();
        }
    }

public E pollLast(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            E x;
            while ( (x = unlinkLast()) == null) { //链表为空则等待指定的时间
                if (nanos <= 0)
                    return null; //等待超时返回null
                nanos = notEmpty.awaitNanos(nanos);
            }
            return x;
        } finally {
            lock.unlock();
        }
    }

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

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

private E unlinkFirst() {
        // assert lock.isHeldByCurrentThread();
        Node<E> f = first;
        if (f == null) //链表为空，返回null
            return null;
        Node<E> n = f.next;//获取下一个节点
        E item = f.item;
        f.item = null;
        f.next = f; //next指向自己，从链表中移除
        first = n; //重置链表头
        if (n == null)
            last = null; //如果first就是最后一个元素了，将last也置为null，因为这两个最初都是指向同一个元素
        else
            n.prev = null; //将first的前一个元素置为null
        //元素个数减1    
        --count;
        //唤醒因为线程满的而阻塞的线程
        notFull.signal();
        return item;
    }

private E unlinkLast() {
        // assert lock.isHeldByCurrentThread();
        Node<E> l = last;
        if (l == null)  //链表为空，返回null
            return null;
        Node<E> p = l.prev; //获取前一个节点
        E item = l.item;  
        l.item = null;
        l.prev = l; //prev指向自己，从链表中移除
        last = p;
        if (p == null)
            first = null; //如果last就是最后一个元素了，将first也置为null
        else
            p.next = null;
        //元素个数减1         
        --count;
        //唤醒因为线程满的而阻塞的线程
        notFull.signal();
        return item;
    }

5、remove / clear /drainTo

      remove方法有两个重载版本，一个不带参数，调用removeFirst方法实现，removeFirst会移除链表头并返回关联的元素，调用pollFirst实现；与之对应的removeLast会移除链表尾并返回关联的元素，调用pollLast实现，这两个如果返回的元素为null会抛出异常。

     remove的另一个带参数的版本可以指定需要移除的元素，调用removeFirstOccurrence方法实现，该方法会从链表头开始往后遍历直到找到与目标元素匹配的节点，将该节点从链表中移除，然后返回true，如果没有找到返回false；与removeFirstOccurrence对应的，有一个removeLastOccurrence方法，从链表尾开始往前遍历直到找到与目标元素匹配的节点，将该节点从链表中移除，然后返回true，如果没有找到返回false。

     clear方法表示将链表中的节点都移除， drainTo方法表示将链表中的元素移除并放到指定的集合中，如果没有指定数量，则默认将链表中所有元素都移除，如果指定数量了，则移除指定数量的元素，直到链表为空为止。

public E remove() {
        return removeFirst();
    }

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 boolean remove(Object o) {
        return removeFirstOccurrence(o);
    }

public boolean removeFirstOccurrence(Object o) {
        if (o == null) return false;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //从链表头往后遍历
            for (Node<E> p = first; p != null; p = p.next) {
                if (o.equals(p.item)) { //找到目标节点将其从链表中移除，返回true
                    unlink(p);
                    return true;
                }
            }
            return false; //没有找到返回false
        } finally {
            lock.unlock();
        }
    }

public boolean removeLastOccurrence(Object o) {
        if (o == null) return false;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //从链表尾往前遍历
            for (Node<E> p = last; p != null; p = p.prev) {
                if (o.equals(p.item)) {
                    unlink(p);
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //从链表头往后遍历，将所有元素从链表中移除
            for (Node<E> f = first; f != null; ) {
                f.item = null;
                Node<E> n = f.next;
                f.prev = null;
                f.next = null;
                f = n;
            }
            //first和last都置为null，元素个数置为0
            first = last = null;
            count = 0;
            notFull.signalAll();
        } finally {
            lock.unlock();
        }
    }

public int drainTo(Collection<? super E> c) {
        //将队列中的所有元素拷贝到c中
        return drainTo(c, Integer.MAX_VALUE);
    }

public int drainTo(Collection<? super E> c, int maxElements) {
        //参数校验
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        if (maxElements <= 0)
            return 0;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //取两者的最小值
            int n = Math.min(maxElements, count);
            for (int i = 0; i < n; i++) {
                //这里没有使用pollFirst是为了避免锁重入
                //将first节点的元素添加到c中
                c.add(first.item);   // In this order, in case add() throws.
                //移除链表头
                unlinkFirst();
            }
            return n;
        } finally {
            lock.unlock();
        }
    }

6、push / pop

      这两个用法用于实现先进后出的栈，这两方法都不会阻塞，其实现如下：

//push时都是插入到链表头
public void push(E e) {
        addFirst(e);
    }

//pop时都是从链表头移除元素，即后插入的元素会先出
public E pop() {
        return removeFirst();
    }

7、iterator / descendingIterator

      iterator用于从链表头开始遍历，descendingIterator用于从链表尾开始遍历，其实现如下：

public Iterator<E> iterator() {
        return new Itr();
    }

public Iterator<E> descendingIterator() {
        return new DescendingItr();
    }

Itr和DescendingItr都是内部类，都继承自AbstractItr，其实现如下：

 AbstractItr的实现如下：

private abstract class AbstractItr implements Iterator<E> {
        //下一次next方法对应的节点
        Node<E> next;

        //下一次next方法关联的元素
        E nextItem;

        //上一次next方法返回的节点
        private Node<E> lastRet;

        abstract Node<E> firstNode();
        abstract Node<E> nextNode(Node<E> n);

        AbstractItr() {
            // set to initial position
            final ReentrantLock lock = LinkedBlockingDeque.this.lock;
            lock.lock();
            try {
                //获取第一个节点
                next = firstNode();
                nextItem = (next == null) ? null : next.item;
            } finally {
                lock.unlock();
            }
        }

        public boolean hasNext() {
            return next != null;
        }

        public E next() {
            if (next == null)
                throw new NoSuchElementException();
            lastRet = next;
            E x = nextItem;
            advance();
            return x;
        }

        /**
         * next方法调用此方法获取下一次返回的节点
         */
        void advance() {
            final ReentrantLock lock = LinkedBlockingDeque.this.lock;
            lock.lock();
            try {
                //获取下一个遍历的元素
                next = succ(next);
                nextItem = (next == null) ? null : next.item;
            } finally {
                lock.unlock();
            }
        }

       private Node<E> succ(Node<E> n) {
            for (;;) {
                //获取下一个节点
                Node<E> s = nextNode(n);
                if (s == null)
                    return null;
                else if (s.item != null)
                    return s;
                else if (s == n) 
                //如果这个节点刚好从链表移除了，则从头开始遍历，正常不会出现此情形，因为advance和元素移除都是在锁下进行的
                    return firstNode();
                else
                    n = s;
            }
        }


        public void remove() {
            Node<E> n = lastRet;
            if (n == null)
                throw new IllegalStateException();
            lastRet = null;
            final ReentrantLock lock = LinkedBlockingDeque.this.lock;
            lock.lock();
            try {
                if (n.item != null)
                    unlink(n); //将上一次返回的节点从链表中移除
            } finally {
                lock.unlock();
            }
        }
    }

 

孙大圣666
关注
专栏目录
【JUC源码专题】LinkedBlockingDeque 源码分析（JDK8）
秀强的专栏
09-21 442
LinkedBlockingDeque 是基于链表实现的双端阻塞队列，我们可以从队列的头部和尾部插入或者读取元素。
Java8 ConcurrentLinkedDeque 源码解析
菜鸟进阶之路
04-15 658
目录 1、定义 3、add /offer /addAll 4、peek /poll /remove 5、unlinkFirst /unlinkLast 6、unlink 7、iterator /descendingIterator ConcurrentLinkedDeque表示一个无固定容量的，线程安全的，基于CAS而非ReentrantLock互斥锁实现...
JUC集合类 LinkedBlockingDeque源码解析 JDK8
anlian523的博客
07-30 724
和ArrayBlockingQueue一样，使用一个Lock和两个Condition来控制并发和阻塞。因为两端都可以入队出队，所以用一个锁才能保证正确。 和LinkedBlockingQueue不同的是，我们初始化时，连dummy node也没有。 从first端移除的节点，next指针指向自身，以区别于first指向节点（next指针不会指向自身，可能为真实节点或null）。从last端移除的节点同理。
java进阶|LinkedBlockingDeque源码分析
qq_35006660的博客
06-15 120
这是关于java集合类源码分析文章的最后一篇，后面或许会随着自己的一些理解，自己还是会再来写一两篇集合源码分析的文章，因为目前自己的理解，有些集合的源码自己确实理解不了，所以我就不继续分...
Java 并发 --- 阻塞队列之LinkedBlockingDeque源码分析
小张的专栏
11-20 1651
LinkedBlockingDeque是基于双向链表的双端有界阻塞队列，默认使用非公平ReentrantLock实现线程安全，默认队列最大长度都为Integer.MAX_VALUE；不允许null元素添加；双端队列可以用来实现 "窃取算法" ,两头都可以操作队列，相对于单端队列可以减少一半的竞争。
阻塞队列（三）—— LinkedBlockingDeque源码
qq_45966902的博客
02-11 496
标题LinkedBlockingDeque源码 简介 LinkedBlockingDeque是一个双端队列，可以消费队头以及队尾的元素，我们可以设定最大容量，但是设定好后不可改变，因为被final修饰了，然后没有设置的话默认是Integer的最大值，只有一把锁和两个条件队列 下面来看看源码 源码 首先是重要内部类 //Node节点 static final class Node<E> { //元素value E item; //前继节点
JAVA8 CompletableFuture 异步编排 异步回调 案例实现 源码解析
NeverGiveUp
09-01 863
JUC CompletableFuture 异步编排 使用场景: ​ 当业务逻辑复杂时,特别是在微服务下,有些数据还需要远程调用.多个业务逻辑独立运行将耗费更多的时间. 例如: 查询商品基本信息 -> 0.5s 查询商品库存信息(远程调用) -> 1s 查询商品图片 -> 0.5s 查询商品规格属性 (依赖商品基本信息查询结果) -> 0.5s 提交所有商品信息
深入源码，深度解析Java 线程池的实现原理，java高级进阶书籍
m0_65485011的博客
12-18 646
this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; } } 主要参数就是下面这几个： corePoolSize：线程池中的核心线程数，包括空闲线程，也就是核心线程数的大小； maximumPoolSize：线程池中允许的最多的线程数，也就是说线程池中的线程数是不可能超过该值的； keepAliveTime：当线程池中的线程数大于
AQS之BlockingQueue源码解析
Me_xuan的博客
09-23 265
目录 BlockingQueue介绍 队列类型 常见的5种阻塞队列 BlockingQueue中API BlockingQueue源码解析 ArrayBlockingQueue简单图解 BlockingQueue介绍 BlockingQueue 是一个先进先出（FIFO）的阻塞队列。 BlockingQueue，java.util.concurrent 包提供的用于解决并发生产者 - 消费者问题的最有用的类，它的特性是在任意时刻只有一个线程可以进行take或者put操作，并且Blockin
LinkedBlockingDeque的源码解析（基于JDK1.8）
weixin_43740011的博客
06-02 277
LinkedBlockingDeque是一个高效的双向队列，能够提供高并发的访问能力。我们可以通过它提供的各种插入、移除、检索和其它操作来满足不同的业务需求。
LinkedBlockingDeque<E>源码详解
p812438109的专栏
01-05 323
一）LinkedBlockingDeque<E>简介 LinkedBlockingDeque<E>源码详解(基于jdk1.8.0_162) 1）底层由双链表实现。 2）是一个可以双端操作的阻塞队列（先进先出，先进后出）。 3）创建时，可指定队列初始容量，如未指定，默认为Integer.MAX_VALUE，指定后不能修改。是一个线程安全的队列。 类图：Link...
Java LinkedBlockingDeque阻塞双端队列源码深度解析
终生学习践行者
08-07 2359
基于JDK1.8详细介绍了LinkedBlockingDeque的底层源码实现，包括双端队列的入队列、出队列、迭代等操作源码。实际上LinkedBlockingDeque的源码还是非常简单的！
Java LinkedBlockingQueue源码深度解析
终生学习践行者
07-24 2933
基于JDK1.8详细介绍了LinkedBlockingQueue的底层源码实现，包括锁分离的原理，以及入队列、出队列等操作源码。实际上LinkedBlockingQueue的源码还是非常简单的！
JDK8系列：阻塞队列 之 LinkedBlockingDeque（双向阻塞队列）源码解析
啦卡的博客
11-07 441
1、LinkedBlockingDeque 简介 LinkedBlockingDeque是一个基于链表的双端阻塞队列。和LinkedBlockingQueue类似，区别在于该类实现了Deque接口，而LinkedBlockingQueue实现了Queue接口。该类的继承关系如下图： 容量问题 LinkedBlockingDeque是一个可选容量的阻塞队列，如果没有设置容量，那么容量将是Int的最大值。 底层数据结构 LinkedBlockingDeque的底层数据结构是一个双端队列，该队列使用链.
java: LinkedBlockingQueue之drainTo
amadeus_liu2的博客
08-15 1367
java
LinkedBlockingQueue的drainTo方法
weixin_42594143的博客
11-22 1361
LinkedBlockingQueue的drainTo方法
Java中LinkedBlockingDeque类中drainTo方法的运用与实现原理
最新发布
Coder-文小白的博客
07-23 1248
最近在项目开发中，有使用到类做数据存储。是Java并发编程中一种常见的阻塞队列，它是线程安全的，采用链表的方式实现，具有先进先出的特性，它几乎可以无限扩展，并且可以阻塞读取和阻塞写入。在项目中，某一个工具类中，采用了来进行数据存储，需要在使用的时候进行队列进行是否存在数据，否则进行遍历操作，同时操作完成以后，需要及时重置队列，此时类中的drainTo方法，刚好可以满足需求。drainTo方法，主要作用是将队列中的集合元素转移到指定的集合中，下面介绍一下常见的使用方式。可以看到drainTo。
java从队头到队尾_Java同步数据结构之LinkedBlockingDeque
weixin_39593469的博客
02-27 283
前言前面介绍完了队列Queue/BlockingQueue的实现类，接下来介绍双端队列Deque/BlockingDeque的实现类之一LinkedBlockingDeque，它是一种基于链表的可选容量的同时支持FIFO、LIFO的阻塞双端队列。比起前面介绍的队列实现中的节点都有一个指向下一个节点的next字段引用，双端队列为了能够实现能够从尾部添加元素，在队列节点类中不但有指向下一个节点的nex...
java阻塞队列LinkedBlockingDeque
weixin_40651983的博客
04-10 143
/* * 基于双链表实现的阻塞队列（双端队列） * 使用ReentrantLock 进行同步处理 * */ /*创建一个默认容量的阻塞队列,容量为Integer.MAX_VALUE*/ LinkedBlockingDeque queue = new LinkedBlockingDeque();...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值