015.多线程-并发队列

版权声明:本文为博主原创文章,允许转载,请标明出处。

在并发队列上JDK提供了两套实现, 一个是以ConcurrentLinkedQueue为代表的高性能队列, 一个是以BlockingQueue接口为代表的阻塞队列,无论哪种都继承自Queue。


ConcurrentLinkedQueue

ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列, 通过无锁的方式,实现了高并发状态下的高性能, 通常ConcurrentLinkedQueue性能好于BlockingQueue。 它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。 头是最先加入的,尾是最近加入的,该队列不允许null元素。

  • add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别) public boolean add(E e) { return offer(e); }
  • poll() 和peek() 都是取头元素节点,区别在于前者会删除元素,后者不会。 package cn.qbz.thread; import java.util.concurrent.ConcurrentLinkedQueue; public class Test111904 { public static void main(String[] args) { ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue(); for (int i = 0; i < 3; i++) { new ThreadTest111904(queue).start(); } while (true) { if (queue.size() > 0) { System.out.println(queue.poll()); } } } } class ThreadTest111904 extends Thread { private ConcurrentLinkedQueue queue; public ThreadTest111904(ConcurrentLinkedQueue queue) { this.queue = queue; } @Override public void run() { for (int i = 0; i < 3; i++) { queue.offer(getName() + "..." + i); } } }

BlockingQueue

在队列为空时,获取元素的线程会等待队列变为非空。 当队列满时,存储元素的线程会等待队列可用。 阻塞队列常用于生产者和消费者的场景

ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的阻塞队列,它的内部实现是一个数组。 有边界的意思是它的容量是有限的, 我们必须在其初始化的时候指定它的容量大小, 容量大小一旦指定就不可改变。

package cn.qbz.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class Test111905 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue(2);
        queue.add("test1");
        queue.offer("test2");

        Boolean isOffer = queue.offer("test3");
        System.out.println("添加test3:"+isOffer);

        isOffer = queue.offer("test4", 1, TimeUnit.SECONDS);
        System.out.println("添加test4:"+isOffer);

        for (int i = 0; i < 4; i++) {
            System.out.println(queue.poll());
        }
    }
}

其中,add和offer的区别是: 当超出队列界限时,add会抛出异常,offer只是返回false。


LinkedBlockingQueue

LinkedBlockingQueue阻塞队列大小的配置是可选的, 如果我们初始化时指定一个大小,它就是有边界的, 如果不指定,它就是无边界的。说是无边界, 其实是采用了默认大小为Integer.MAX_VALUE的容量 。 它的内部实现是一个链表。

code of demo:

package cn.qbz.thread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Test111906 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue queue = new LinkedBlockingDeque(3);
        Produce111906 p1 = new Produce111906(queue);
        Consumer111906 c1 = new Consumer111906(queue);
        
        Thread produce1 = new Thread(p1);
        Thread produce2 = new Thread(p1);
        Thread consumer1 = new Thread(c1);

        produce1.start();
        produce2.start();
        consumer1.start();

        Thread.sleep(1000 * 10);

        p1.stop();
        c1.stop();
    }

}

class Produce111906 implements Runnable {
    private BlockingQueue<String> queue;
    private volatile Boolean flag = true;
    private AtomicInteger count = new AtomicInteger();

    public Produce111906(BlockingQueue queue) {
        this.queue = queue;
    }

    public void run() {
        while (flag) {
            try {
                int data = count.incrementAndGet();
                System.out.println("开始生产数据:" + data);
                Boolean isOffer = queue.offer(data + "", 2, TimeUnit.SECONDS);
                if (isOffer) {
                    System.out.println("写入数据:" + data + "成功");
                } else {
                    System.out.println("写入数据:" + data + "失败");
                }
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("退出本次生产");
            }
        }

    }

    public void stop() {
        flag = false;
    }
}

class Consumer111906 implements Runnable {
    private BlockingQueue<String> queue;
    private volatile Boolean flag = true;

    public Consumer111906(BlockingQueue queue) {
        this.queue = queue;
    }

    public void run() {
        while (flag) {
            System.out.println("开始消费数据");
            try {
                String data = queue.poll(2, TimeUnit.SECONDS);
                if (data != null) {
                    System.out.println("消费成功:" + data);
                } else {
                    System.out.println("消费失败");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public void stop() {
        flag = false;
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Ryan Miao

java中byte, iso-8859-1, UTF-8,乱码的根源

Post@https://ryan-miao.github.io 测试代码https://github.com/Ryan-Miao/someTest/comm...

6007
来自专栏JavaEE

Java常用设计模式

工厂是干嘛的,就是用来生产的嘛,这里说的工厂也是用来生产的,它是用来生产对象的。也就是说,有些对象我们可以在工厂里面生产,需要用时直接从工厂里面拿出来即可,而不...

1661
来自专栏java一日一条

50个常见的 Java 错误及避免方法(第二部分)

System.out.println("Whatdo you want to do?");

1163
来自专栏CDA数据分析师

学完Python基础知识后,你真的会python吗?

前言 最近觉得 Python 太“简单了”,于是在师父川爷面前放肆了一把:“我觉得 Python 是世界上最简单的语言!”。于是川爷嘴角闪过了一丝轻蔑的微笑(内...

36710
来自专栏博岩Java大讲堂

Java集合--阻塞队列(LinkedBlockingQueue)

4019
来自专栏技术与生活

设计模式-代理模式

以上属于静态代理,比较简单。与之对应的是动态代理,在运行时间内创建代理对象,JDK提供了 Proxy 和InvokationHandler 来处理 首先构造动态...

921
来自专栏博岩Java大讲堂

Java集合--线程安全(CopyOnWrite机制)

3274
来自专栏java一日一条

Java 高并发综合

这篇文章是研一刚入学时写的,今天整理草稿时才被我挖出来。当时混混沌沌的面试,记下来了一些并发的面试问题,很多还没有回答。到现在也学习了不少并发的知识,回过头来看...

1903
来自专栏coolblog.xyz技术专栏

MyBatis 源码分析 - 配置文件解析过程

由于本篇文章篇幅比较大,所以这里拿出一节对本文进行快速概括。本篇文章对 MyBatis 配置文件中常用配置的解析过程进行了较为详细的介绍和分析,包括但不限于se...

1072
来自专栏码生

swift 增加 Xcode 编译速度 减少 Xcode 编译时间 日常注意事项

swift 是编译型语言,所以编译时间相比较 OC 是要增加不少时间的 swift 在 编译的时候花费做多的时间就是,类型推断 关于影响编译速度和统计编译时...

1432

扫码关注云+社区

领取腾讯云代金券