jdk-ConcurrentLinkedQueue（二）

最新推荐文章于 2021-09-04 11:36:36 发布
最新推荐文章于 2021-09-04 11:36:36 发布
阅读量255 收藏
点赞数
分类专栏： jdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32924343/article/details/72831995
版权

第一篇详细画出了在入队和出队时的操作，看的真的很费时，说实话，我看了好几遍才动手开始画队列变换的图，并且在画图时还时不时的修正了很多次。。。总结出，对于jdk源码的话，多看几遍总能看出作者的意图的，不要害怕看不懂，看不懂第一遍，看二遍，三遍。

这次的博客去看下此类中的其他一些方法，准备为将来的使用坐下基础。

succ方法，向后推进方法，可以看出获取的是当前节点的后继节点，比较了 p 和next是否相等，在第一篇博客分析时，发现在出队情况下，是有可能出现next指向自身的节点，出现这个节点，意味着出队执行成功，并且设置了新的head节点，head节点指向了下一个有效的队列头。

 final Node<E> succ(Node<E> p) {
        Node<E> next = p.next;
        return (p == next) ? head : next;
    }


peek方法，跟出队操作很类似，获取当前head指向的节点，判读item是否为null

1. item 不为null，更新head指向，并返回当前item值。

2.item为 null，判断当前节点是否到达了尾部，如果是尾部的话，更新head节点指于此，如果不是尾部的话，判断是够指向自身，都不是的话，p节点后移，重新获取下一个节点的item值。peek方法总的来说是获取head节点之后第一个有效节点。

public E peek() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;
                if (item != null || (q = p.next) == null) {
                    updateHead(h, p);
                    return item;
                }
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }
first方法。返回的是head节点之后的第一个不为null的有效节点的item值，可以看见，如果当前节点到达尾部的话，会更新一下head的值，并且会判断当前尾部节点的item是否是null，是的话返回空节点，不是的话返回有效节点 
Node<E> first() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                boolean hasItem = (p.item != null);
                if (hasItem || (q = p.next) == null) {
                    updateHead(h, p);
                    return hasItem ? p : null;
                }
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }
isEmpty 字面意思判空。

如果head处的节点item值不为null，那么first会立即返回这个节点，立马知道这个队列不空。

如果first返回的是null的话，说明从head处读取到之后的节点都为null一直到最后的尾部节点，依然是null，才最终返回null。注意此处是从head节点开始读取的，head节点在出队操作中会不断变化。那么只有在这个队列全为null时,才会去遍历整个队列。

 public boolean isEmpty() {
        return first() == null;
    }
可以看见size方法并不适用于判空处理，它会循环整个队列，计算出count值，消耗极大，并且这个count的值也不是准确的，多线程情况下有可能不靠谱，需要我们手动去做同步，注意一下。 
public int size() {
        int count = 0;
        for (Node<E> p = first(); p != null; p = succ(p))
            if (p.item != null)
                // Collection.size() spec says to max out
                if (++count == Integer.MAX_VALUE)
                    break;
        return count;
    }
contains方法，去队列中寻找是否包含这个item项的节点。跟size方法一样，使用succ方式去遍历，但是这个方法一样会出现数据不同步的情况。 
public boolean contains(Object o) {
        if (o == null) return false;
        for (Node<E> p = first(); p != null; p = succ(p)) {
            E item = p.item;
            if (item != null && o.equals(item))
                return true;
        }
        return false;
    }

使用ConcurrentLinkedQueue实现生产者消费者went 
public class TestConcurrentLinkedDeque {


    public static void main(String[] args) {

        ConcurrentLinkedQueue<Food> foods = new ConcurrentLinkedQueue<Food>();

        final Provider provider = new Provider(foods);
        final Customer customer = new Customer(foods);

        for(int i = 0; i < 10; i ++){
            new Thread(new Runnable() {
                public void run() {
                    provider.runP();
                }
            }).start();
        }

        for(int i = 0; i < 10; i ++){
            new Thread(new Runnable() {
                public void run() {
                    customer.runC();
                }
            }).start();
        }
    }



}

public class Provider {
    private ConcurrentLinkedQueue<Food> foods;
    /*采用原子Integer，可以完美解决多线程环境下数目的变换*/
    private AtomicInteger num = new AtomicInteger();

    public Provider(ConcurrentLinkedQueue<Food> foods) {
        this.foods = foods;
    }

    public void runP() {
        // TODO Auto-generated method stub
        while (true) {
            int index = num.incrementAndGet();
            String name = "甜品  "+index+" 号";
            try {
                foods.offer(new Food(index, name));
                System.out.println(Thread.currentThread()+"生产了第 "+ index + "号 食品: "+name + System.currentTimeMillis());
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

public class Customer {

    private ConcurrentLinkedQueue<Food> foods;

    public Customer(ConcurrentLinkedQueue<Food> foods) {
        this.foods = foods;
    }

    public void runC() {
        // TODO Auto-generated method stub
        while (true) {
            try {
                Food food = foods.poll();
                if(food == null){
                    System.err.println(Thread.currentThread()+ "消费失败，无数据生产出 " +System.currentTimeMillis());
                }else {
                    System.err.println(Thread.currentThread()+ "消费了第 "+food.getNum()+"食品 : " + food.getName()+System.currentTimeMillis());
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

Thread[Thread-0,5,main]生产了第 1号 食品: 甜品  1 号1496710329448
Thread[Thread-2,5,main]生产了第 2号 食品: 甜品  2 号1496710329448
Thread[Thread-4,5,main]生产了第 3号 食品: 甜品  3 号1496710329449
Thread[Thread-6,5,main]生产了第 4号 食品: 甜品  4 号1496710329449
Thread[Thread-8,5,main]生产了第 5号 食品: 甜品  5 号1496710329449
Thread[Thread-10,5,main]消费了第 1食品 : 甜品  1 号1496710329450
Thread[Thread-12,5,main]消费了第 2食品 : 甜品  2 号1496710329450
Thread[Thread-14,5,main]消费了第 3食品 : 甜品  3 号1496710329450
Thread[Thread-16,5,main]消费了第 4食品 : 甜品  4 号1496710329451
Thread[Thread-18,5,main]消费了第 5食品 : 甜品  5 号1496710329451
Thread[Thread-11,5,main]消费了第 6食品 : 甜品  6 号1496710329451
Thread[Thread-13,5,main]消费了第 7食品 : 甜品  7 号1496710329451
Thread[Thread-15,5,main]消费了第 8食品 : 甜品  8 号1496710329451
Thread[Thread-17,5,main]消费了第 9食品 : 甜品  9 号1496710329451
Thread[Thread-19,5,main]消费了第 10食品 : 甜品  10 号1496710329452
Thread[Thread-1,5,main]生产了第 6号 食品: 甜品  6 号1496710329451
Thread[Thread-3,5,main]生产了第 7号 食品: 甜品  7 号1496710329451
Thread[Thread-5,5,main]生产了第 8号 食品: 甜品  8 号1496710329451
Thread[Thread-7,5,main]生产了第 9号 食品: 甜品  9 号1496710329451
Thread[Thread-9,5,main]生产了第 10号 食品: 甜品  10 号1496710329451
Thread[Thread-10,5,main]消费了第 12食品 : 甜品  12 号1496710331450
Thread[Thread-14,5,main]消费了第 13食品 : 甜品  13 号1496710331450
Thread[Thread-12,5,main]消费了第 11食品 : 甜品  11 号1496710331450
Thread[Thread-18,5,main]消费了第 14食品 : 甜品  14 号1496710331451
Thread[Thread-16,5,main]消费了第 15食品 : 甜品  15 号1496710331451
Thread[Thread-11,5,main]消费了第 16食品 : 甜品  16 号1496710331451
Thread[Thread-13,5,main]消费了第 17食品 : 甜品  17 号1496710331451
Thread[Thread-15,5,main]消费了第 18食品 : 甜品  18 号1496710331451
Thread[Thread-0,5,main]生产了第 11号 食品: 甜品  11 号1496710331448
Thread[Thread-17,5,main]消费了第 19食品 : 甜品  19 号1496710331452
Thread[Thread-2,5,main]生产了第 12号 食品: 甜品  12 号1496710331448
Thread[Thread-19,5,main]消费了第 20食品 : 甜品  20 号1496710331452
Thread[Thread-4,5,main]生产了第 13号 食品: 甜品  13 号1496710331449
Thread[Thread-6,5,main]生产了第 14号 食品: 甜品  14 号1496710331449
Thread[Thread-8,5,main]生产了第 15号 食品: 甜品  15 号1496710331449
Thread[Thread-1,5,main]生产了第 16号 食品: 甜品  16 号1496710331451
Thread[Thread-3,5,main]生产了第 17号 食品: 甜品  17 号1496710331451
Thread[Thread-9,5,main]生产了第 18号 食品: 甜品  18 号1496710331451
Thread[Thread-5,5,main]生产了第 19号 食品: 甜品  19 号1496710331451
Thread[Thread-7,5,main]生产了第 20号 食品: 甜品  20 号1496710331451
Thread[Thread-10,5,main]消费了第 21食品 : 甜品  21 号1496710333450
Thread[Thread-12,5,main]消费了第 22食品 : 甜品  22 号1496710333450
Thread[Thread-14,5,main]消费了第 23食品 : 甜品  23 号1496710333450
Thread[Thread-16,5,main]消费了第 24食品 : 甜品  24 号1496710333451
Thread[Thread-18,5,main]消费了第 25食品 : 甜品  25 号1496710333451
Thread[Thread-11,5,main]消费了第 26食品 : 甜品  26 号1496710333451
Thread[Thread-15,5,main]消费失败，无数据生产出 1496710333451
Thread[Thread-15,5,main]消费失败，无数据生产出 1496710333451
Thread[Thread-15,5,main]消费失败，无数据生产出 1496710333451
Thread[Thread-15,5,main]消费了第 27食品 : 甜品  27 号1496710333451
Thread[Thread-13,5,main]消费了第 28食品 : 甜品  28 号1496710333451
Thread[Thread-0,5,main]生产了第 21号 食品: 甜品  21 号1496710333448
Thread[Thread-2,5,main]生产了第 22号 食品: 甜品  22 号1496710333448
Thread[Thread-4,5,main]生产了第 23号 食品: 甜品  23 号1496710333449
Thread[Thread-6,5,main]生产了第 24号 食品: 甜品  24 号1496710333449
Thread[Thread-8,5,main]生产了第 25号 食品: 甜品  25 号1496710333449
Thread[Thread-3,5,main]生产了第 26号 食品: 甜品  26 号1496710333451
Thread[Thread-1,5,main]生产了第 27号 食品: 甜品  27 号1496710333451
Thread[Thread-9,5,main]生产了第 28号 食品: 甜品  28 号1496710333451
Thread[Thread-5,5,main]生产了第 29号 食品: 甜品  29 号1496710333451
Thread[Thread-7,5,main]生产了第 30号 食品: 甜品  30 号1496710333451
Thread[Thread-17,5,main]消费了第 29食品 : 甜品  29 号1496710333452
Thread[Thread-19,5,main]消费了第 30食品 : 甜品  30 号1496710333452
Thread[Thread-0,5,main]生产了第 31号 食品: 甜品  31 号1496710335449
Thread[Thread-2,5,main]生产了第 32号 食品: 甜品  32 号1496710335449
Thread[Thread-4,5,main]生产了第 33号 食品: 甜品  33 号1496710335450
Thread[Thread-8,5,main]生产了第 34号 食品: 甜品  34 号1496710335450
Thread[Thread-6,5,main]生产了第 35号 食品: 甜品  35 号1496710335450
Thread[Thread-3,5,main]生产了第 36号 食品: 甜品  36 号1496710335452
Thread[Thread-1,5,main]生产了第 37号 食品: 甜品  37 号1496710335452
Thread[Thread-9,5,main]生产了第 38号 食品: 甜品  38 号1496710335452
Thread[Thread-5,5,main]生产了第 39号 食品: 甜品  39 号1496710335452
Thread[Thread-7,5,main]生产了第 40号 食品: 甜品  40 号1496710335452
Thread[Thread-10,5,main]消费了第 31食品 : 甜品  31 号1496710335451
Thread[Thread-12,5,main]消费了第 32食品 : 甜品  32 号1496710335451
Thread[Thread-14,5,main]消费了第 33食品 : 甜品  33 号1496710335451
Thread[Thread-16,5,main]消费了第 34食品 : 甜品  34 号1496710335452
Thread[Thread-18,5,main]消费了第 35食品 : 甜品  35 号1496710335452
Thread[Thread-11,5,main]消费了第 36食品 : 甜品  36 号1496710335452
Thread[Thread-13,5,main]消费了第 37食品 : 甜品  37 号1496710335452
Thread[Thread-15,5,main]消费失败，无数据生产出 1496710335452
Thread[Thread-15,5,main]消费了第 38食品 : 甜品  38 号1496710335452
Thread[Thread-17,5,main]消费了第 39食品 : 甜品  39 号1496710335453
Thread[Thread-19,5,main]消费了第 40食品 : 甜品  40 号1496710335453

实现方式和LinkBlobkedQueue类似

刘二郎
关注
专栏目录
并发编程系列之并发容器：ConcurrentLinkedQueue
吭哧吭哧快乐的小牛码
06-12 1万+
前言 上节我们介绍了线程安全的HashMap，今天我们再来介绍一个线程安全的并发容器：ConcurrentLinkedQueue，它是一个线程安全的队列，在Java中如果要实现一个线程安全的队列由2种方式：一个是使用阻塞算法的队列，用一个锁（入队和出队列共享同一把锁）或者两个锁（入队和出队各持一把锁）来实现，另一个是使用非阻塞的CAS方式来实现，今天我们我们就来一起看看如何使用非阻塞方式实现ConcurrentLinkedQueue，OK，让我们扬帆起航，开始今天的并发之旅吧。 什么是Concur.
JUC源码分析-容器-ConcurrentLinkedQueue
chenchangqun11的专栏
03-11 222
ConcurrentLinkedQueue 是单向链表结构的无界并发队列。从JDK1.7开始加入到J.U.C的行列中。使用CAS实现并发安全，元素操作按照 FIFO (first-in-first-out 先入先出) 的顺序。适合“单生产，多消费”的场景。 内存一致性遵循对ConcurrentLinkedQueue的插入操作先行发生于(happen-before)访问或移除操作。、？？ ...
ConcurrentLinkedQueue使用和方法介绍
zhangpengc1的博客
07-31 810
定义 一个基于链接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部 是队列中时间最短的元素。 新的元素插入到队列的尾部，队列获取操作从队列头部获得元素。当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许使用 null 元素。 offer和po...
ConcurrentLinkedQueue使用方法
热门推荐
石头视角
01-26 3万+
它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的。插入元素是追加到尾上。提取一个元素是从头提取。当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。该队列不允许null元素。此实现采用了有效的“无等待 (wait-free)”算法，该算法基于 Maged M. Michael 和
线程池流程原理分析、并发队列ConcurrentLinkedDeque、BlockingQueue阻塞队列介绍以及合理配置线程池
qq_41854137的博客
12-09 566
线程池流程图：         线程池原理分析： 部分源码解读： public class ThreadPoolExecutor extends AbstractExecutorService {      /**      * Creates a new {@code ThreadPoolExecutor} with the given initial      * paramete...
jdk-ConcurrentLinkedQueue(一)
lwgzj的博客
05-31 369
研究完LinkedBlockingQueue之后呢，我的关注点又到了ConcurrentLinkedQueue上，不过说实现的，我的jdk是1.7的，1.7的ConcurrentLinkedQueue的代码简洁是够简洁的，但是读起来费力的要死，逻辑分支理解很僵硬，应该有我的原因，但是我去读过1.6的，1.6的明显在各个分支处的逻辑都很容易理解，在此也要注意一下自己的分支可读性，或许自己的代码过个一
Java并发容器（二）：Java并发容器和框架--ConcurrentLinkedQueue（JDK1.7）
GDUT_Trim的博客
09-04 232
并发安全的队列实现ConcurrentLinkedQueue结构拥有的变量属性Node类构造方法入队操作出队操作updateHead方法源码 并发安全的队列实现 ConcurrentLinkedQueue是一个线程安全的队列，队列的并发不安全性其实也就是会出现覆盖的问题 而实现一个线程安全的队列有两种方式去实现，其实总的来说是拥有两种算法 一种是阻塞算法，也就是用锁去控制队列的入队和出队，可以是两个锁也可以是一个锁 另外一种就是非阻塞算法，采用循环CAS的方式去实现，其实也就是乐观锁 而Concurr.
jdk-1.8-API-CHM
05-02
8. **并发更新集合**：并发集合类如ConcurrentHashMap和ConcurrentLinkedQueue等在1.8中得到了优化，提供了更多的原子操作和并发控制。 9. **类型推断增强**：编译器现在能更智能地推断变量的类型，使得var关键字的...
jdk-6u38-windows-x64
07-14
6. **并发工具的增强**：如ConcurrentLinkedQueue和Fork/Join框架，帮助开发者编写高效多线程代码。 7. **垃圾回收器优化**：包括并行和串行垃圾收集器的改进，以提升整体应用性能。 在Windows 64位环境下安装JDK ...
JDK-阻塞队列、非阻塞队列原理
小小少年的博客
04-14 681
在jdk提供的队列中，有阻塞队列和非阻塞队列
Java源码解读系列7—ConcurrentLinkedQueue（JDK1.8 ）
JayLaiSCUT的博客
03-21 4724
1 概述 ConcurrentLinkedQueue（简称CLQ队列）是Queue接口的实现类，是一种无界、非阻塞、线程安全的FIFO队列。CLQ底层存储基于链表，头节点为哨兵节点，里面的数据域（item）为空。插数据时从尾节点插入，取数据时从头节点获取。相对于LinkedBlockingqueue（简称LBQ队列）采用读写各一把锁的机制保证线程安全，CLQ队列采用自旋+CAS机制实现无锁非阻塞。无论是同时有又多个生产者，还是多个消费者，都不会发生线程阻塞，遇到插入失败或者取数据失败的线程就会继续自旋，直到
ConcurrentLinkedQueue使用和方法介绍（转载）
zy103118的博客
08-25 7304
https://www.cnblogs.com/yangzhenlong/p/8359875.html （原文地址） 定义 一个基于链接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部 是队列中时间最短的元素。 新的元素插入到队列的尾部，队列获取操作从队列头部获得元素。当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许使用 null 元素。 ...
ConcurrentLinkedQueue详解
cdn1998的博客
02-05 1322
文章目录Node几个CAS操作入队列单线程入队过程入队操作HOPS的设计意图出队列出队操作 如果要实现一个线程安全的队列有两种方式：一种是使用阻塞算法，即队列用一个锁（入队和出队用同一把锁）或两个锁（入队和出队分别用一把锁）来实现；另一种是使用非阻塞算法，即使用循环CAS的方式实现。而ConcurrentLinkedQueue是使用非阻塞的方式来实现的基于链表的线程安全队列，采用先进先出（FIF...
Object源码分析（一）-- clone方法
lwgzj的博客
09-05 4744
java基类Object 在你编写一个类的时候，若无指定父类（没有显式extends一个父类）编译器（一般编译器完成该步骤）会默认的添加Object为该类的父类（可以将该类反编译看其字节码，不过貌似Java7自带的反编译javap现在看不到了）。  　　再说的详细点：假如类A，没有显式继承其他类，编译器会默认添加Object为其父类；若有，那么那个显式父类呢？要么是没有显式继承，那么Objec
Object源码分析（二）-- hashcode方法
lwgzj的博客
09-22 1806
Object内还有一个hashcode方法，留给子类实现的，但是本身Object的hashcode方法也是可以返回一串hash值的，但是是基于C++写的，本人表示看不懂~~。贴几个博客留待研究吧，表示确实不清楚是怎么得到，需要去研究C++去了。暂时读不懂.http://blog.csdn.net/luanlouis/article/details/41547649http://blog.csdn....
jdk-ThreadPoolExecutor(二)---内部参数和拒绝策略
lwgzj的博客
06-26 1081
承继上一篇，上一篇主要分析了下ThreadPoolExecutor中的大概执行逻辑，这一篇主要分析一下内部参数的写一写测试程序。 首先来看里面的最终的默认构造方法，分析其参数,以及其流程 //Executors中的四个构造方法最终调用的是下面一个初始化方法 public ThreadPoolExecutor(int corePoolSize,
jdk-ThreadPoolExecutor(三)---内部Worker和执行方法
lwgzj的博客
06-26 980
第三篇了，其实关于多线程这边的话，我想一直分下去，每一篇都研究一点，不太想将所有的知识点都放在一起，放在一起，读起来太费力了，看起来也不舒服，分下来之后至少一目了然，一个个知识点很清晰。 今天的话就来看看它的一个内部类worker，这个worker应该算是核心了。 private final class Worker extends AbstractQueuedSynchron
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值