【并发编程】-并发容器

最新推荐文章于 2022-04-19 13:38:58 发布
最新推荐文章于 2022-04-19 13:38:58 发布
阅读量158 收藏
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syx8821/article/details/103982901
版权

在上一篇文章简单了解了一下线程池。自定义线程池有5个参数，其中第五个就是选择并发容器。而Java帮我们封装好的几个线程池，也都用了相应的并发容器，接下来看一下Java中有哪些并发容器呢？

ConcurrentMap、CopyOnWriteArrayList、SynchronizedList、ConcurrentLinkedQueue、LinkedBlockingQueue、ArrayBlockingQueue、DelayQueue、TransferQueue、SynchronousQueue

ConcurrentMap

它是一个接口，实现类有两个：ConcurrentHashMap、ConcurrentSkipListMap

· ConcurrentHashMap

线程安全且高效的HashMap，内容无序。
并发量不是很高的情况，更高效。

· ConcurrentSkipListMap

线程安全且高效的HashMap，内容有序。
对于并发量特表高的程序，使用ConcurrentSkipListMap更高效。

public static void main(String[] args) {
//        ConcurrentMap
        Map<String,String> map=new ConcurrentHashMap<>();//运行时间：1162 高并发不排序
//        Map<String,String> map=new ConcurrentSkipListMap<>();//运行时间：2094  高并发并且排序

        Random r=new Random();
        Thread[] ths=new Thread[100];
        CountDownLatch latch=new CountDownLatch(ths.length);//门闩
        long start=System.currentTimeMillis();
        for(int i=0;i<ths.length;i++) {
            ths[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) map.put("a" + r.nextInt(100), "a" + r.nextInt(100));
                latch.countDown();//门闩值减1
            });
        }

        Arrays.asList(ths).forEach(t->t.start());
        try {
            latch.await();//阻塞等待门闩值为0
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println(end-start);
    }

对此程序来说，并法量为10000，则ConcurrentHashMap执行的时间更短一些。

CopyOnWriteArrayList

使用了“写时复制”的思想。
只在增删改上加了锁，查没有加锁，但是它在高并发下不会出问题。因为它在增删改都是将队列复制一份，修改完之后再将地址指向修改完成的那个队列。
故它的特点是：读的快，写的慢。

public static void main(String[] args) {
        List<String> lists=
//                new ArrayList<>();//没有锁，会出并发问题，效率高
//                new Vector<>();//有锁
            new CopyOnWriteArrayList<>();//有锁，写的慢，读的快
        Random r=new Random();
        Thread[] ths =new Thread[100];
        for(int i=0;i<ths.length;i++){
            Runnable task=new Runnable() {
                @Override
                public void run() {
                    for(int i=0;i<1000;i++)lists.add("a"+r.nextInt(10000));
                }
            };
            ths[i]=new Thread(task);
        }
        runAndComputeTime(ths);
        System.out.println(lists.size());
    }
    static void runAndComputeTime(Thread[] ths){
        long s1=System.currentTimeMillis();
        Arrays.asList(ths).forEach(t->t.start());
        Arrays.asList(ths).forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long s2=System.currentTimeMillis();
        System.out.println(s2-s1);
    }

这种并发容器的使用场景是：读多写少的业务。

SynchronizedList

加了锁的list。
该对象的每个方法是原子的，但是该对象的两个方法可不是原子的。

public static void main(String[] args) {
        List<String> strs=new ArrayList<>();//没有加锁
        List<String> strsSync= Collections.synchronizedList(strs);//加了锁的list
        
        /*以下两个方法线程不安全*/
        strsSync.add("aaa");//线程安全
        strsSync.remove("aaa");//线程安全
    }

比如以下程序

public class T03_SynchronizedList {
    public static void main(String[] args) {
        List<String> strs = new ArrayList<>();//没有加锁
        List<String> strsSync = Collections.synchronizedList(strs);//加了锁的list

            new Thread(() -> {
                if (strsSync.isEmpty()) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    strsSync.add("aaa");
                }
            }).start();
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (strsSync.isEmpty()) {
            strsSync.add("bbb");
        }
        try {
            TimeUnit.MILLISECONDS.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(strsSync);
}

当strsSync不为空的时候，添加“aaa”。
输出结果：
在这里插入图片描述
显然不是线程安全的。这时候还是需要自己同步的。使用synchronized

public static void main(String[] args) {
        List<String> strs = new ArrayList<>();//没有加锁
        List<String> strsSync = Collections.synchronizedList(strs);//加了锁的list

            System.out.println(strsSync.isEmpty());
            new Thread(() -> {
                synchronized (strsSync) {
                    if (strsSync.isEmpty()) {
                        try {
                            TimeUnit.MILLISECONDS.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        strsSync.add("aaa");
                    }
                }
            }).start();
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (strsSync.isEmpty()) {
            strsSync.add("bbb");
        }
        try {
            TimeUnit.MILLISECONDS.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(strsSync);
}

输出结果：
在这里插入图片描述

ConcurrentLinkedQueue

无界线程安全队列。
常用的方法介绍：
pool：取出第一个元素，队列中也删除。如果队列为空，返回null
peek：读第一个元素，但队列中仍然存在。
offer：将指定元素插入队列的尾部。如果队列为空，返回null

public static void main(String[] args) {
        Queue<String> strs =new ConcurrentLinkedQueue<>();
        for(int i=0;i<10;i++){
            strs.offer("a"+i);
        }
        System.out.println(strs);

        System.out.println(strs.size());

        System.out.println(strs.poll());
        System.out.println(strs.size());

        System.out.println(strs.peek());
        System.out.println(strs.size());
    }

输出结果：
在这里插入图片描述

LinkedBlockingQueue

无界队列。不指定容量，默认为Integer.MAX_VALUE。
读写操作可并行，采用可重入锁保证并发情况下的线程安全。
常用方法：
取元素
take()：队列为空时阻塞
pool()：返回队顶元素，且从队列清除。队列为空时，返回空。
peek()：返回队顶元素，队列保留。队列为空时返回null。
remove()：移除元素。队列为空时抛出异常。成功移除返回true。
添加数据
put()：队列满时阻塞
offer()：队列满时添加失败，返回false。还可以指定等待多长时间之内插入成功返回true
eg：strs.offer(“aaa”,1, TimeUnit.SECONDS);

ArrayBlockingQueue

有界队列。必须指定队列长度。
常用方法参考上边那个，LinkedBlockingQueue。

DelayQueue

延迟队列，执行定时任务。任务按等待时间长短排序

static BlockingQueue<MyTask> tasks=new DelayQueue<>();//等待时间最长的在最前面，里面的任务等待多长时间可以被拿
    static class MyTask implements Delayed{
        long runningTime;

        MyTask(long rt){
            this.runningTime=rt;
        }
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(runningTime=System.currentTimeMillis(),TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            if(this.getDelay(TimeUnit.MILLISECONDS)<o.getDelay(TimeUnit.MILLISECONDS))
                return -1;
            else if(this.getDelay(TimeUnit.MILLISECONDS)>o.getDelay(TimeUnit.MILLISECONDS))
                return 1;
            return 0;
        }
        @Override
        public String toString(){
            return ""+runningTime;
        }

        public static void main(String[] args) throws InterruptedException {
            long now=System.currentTimeMillis();
            MyTask t1=new MyTask(now+1000);
            MyTask t2=new MyTask(now+2000);
            MyTask t3=new MyTask(now+1500);
            MyTask t4=new MyTask(now+2000);
            MyTask t5=new MyTask(now+500);

            tasks.put(t1);
            tasks.put(t2);
            tasks.put(t3);
            tasks.put(t4);
            tasks.put(t5);

            System.out.println(tasks);
            for(int i=0;i<5;i++){
                System.out.println(tasks.take());
            }
        }
    }

TransferQueue

生产的消息直接给消费者，如果没有消费者，会阻塞。

public static void main(String[] args) throws InterruptedException {
        LinkedTransferQueue<String> strs=new LinkedTransferQueue<>();
        new Thread(()->{
            try {
                System.out.println(strs.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();//这个线程注释，程序会阻塞
        strs.transfer("aaa");
        new Thread(()->{
            try {
                System.out.println(strs.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

将第一个线程注释掉，也就是先transfer在取元素，则会阻塞。因为transfer生产的消息必须直接给消费者。

SynchronousQueue

容量为0的队列。
使用put()方法，没有消费者的时候会阻塞等待消费者。
有add()方法，但是使用会报错。

public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> strs=new SynchronousQueue<>();
        new Thread(()->{
            try {
                System.out.println(strs.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        strs.put("aaa");//阻塞等待消费者
//        strs.add("aaa");//不可以
        System.out.println(strs.size());
    }

运行结果：
在这里插入图片描述

上一篇文章介绍了Java中的线程池分别使用的并发容器
FixedThreadPool（固定个数线程池）：LinkedBlockingQueue
CachedThreadPool（弹性线程池）：SynchronousQueue
SingleThreadExecutor（单线程线程池）：LinkedBlockingQueue
ScheduleThreadPool（定时器线程池）：DelayedWorkQueue

苏怡仙-Hart
关注
专栏目录
并发编程模式
yjclsx的博客
07-31 6348
一、future模式 在网上购物时，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的是一直等待到这个答复收到时再去做别的事情，但如果利用Future设计模式就无需等待答复的到来，在等待答复的过程中可以干其他事情。 future模式核心思想就是异步调用，去除了主函数的等待时间，并使得原本需要等待的时...
Java并发容器--LinkedTransferQueue
学亮编程手记
11-11 315
package com.zhangxueliang.demo.springbootdemo.normal; import java.util.concurrent.LinkedTransferQueue; /** * @ProjectName springbootdemo_src * @ClassName TransferQueue * @Desicription TODO * @A...
Java并发编程-并发容器
a1158375969的专栏
05-06 135
概述 同步容器将所有的操作都串行化,这虽然实现了线程安全, 但是代价是严重降低性能和并发性.并发容器是针对多个线程并发访问来设计的, 通过并发容器, 可以极大的提高伸缩性并降低风险. 并发容器: ConcurrentHashMap, CopyOnWriteArrayList,Queue, BlockingQueue. 并发容器 ConcurrentHashMap 使用分段锁(Lock stripi...
java并发编程--同步容器类&并发类容器
别浪
11-25 744
package cn.bufanli.test.synchronizedDemo; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Vector; /** * 同步类容器都是线程安全的,但在某些场景下可能需要加锁来保护复合操作 * 复合操作如: 迭...
Java-并发工具-并发容器-ConcurrentHashMap
代码充实生活的博客
04-09 127
前言 获取Java并发编程思维导图：Java并发编程-首页 关注微信公众号及时推送更多知识：当代猿 内容详情
Java-并发工具-并发容器-CopyOnWriteArraySet
代码充实生活的博客
04-09 152
前言 获取Java并发编程思维导图：Java并发编程-首页 关注微信公众号及时推送更多知识：当代猿 内容详情
Java-并发工具-并发容器-ThreadLocal
代码充实生活的博客
04-09 135
前言 获取Java并发编程思维导图：Java并发编程-首页 关注微信公众号及时推送更多知识：当代猿 内容详情
Java-并发工具-并发容器-CopyOnWriteArrayList
代码充实生活的博客
04-09 109
前言 获取Java并发编程思维导图：Java并发编程-首页 关注微信公众号及时推送更多知识：当代猿 内容详情
java并发编程之-JUC并发容器的使用
热门推荐
长草颜团子
08-11 7万+
在 Java 5.0 提供了java.util.concurrent(简称JUC)并发编程容器包,在此包中增加了在并发编程中很常用的工具类,用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中的 Collection 实现等 我们拿其中常用的list容器来作为例子,进行高压(高并发测试),使用代码和JMter测试工具来分别测试线程安全问题...
Java并发编程-并发容器1
08-03
【Java并发编程-并发容器1】 在Java的并发编程中，容器的线程安全是至关重要的。HashMap在多线程环境下可能导致CPU利用率极高，因为它不是线程安全的。HashTable虽然提供了线程安全，但其同步机制导致并发性能较低。...
java并发编程-构建块
05-24
5. **并发容器**：Java集合框架中的并发容器如`ConcurrentHashMap`、`ConcurrentLinkedQueue`等，设计时考虑了并发性能，避免了线程安全问题。这些容器内部使用了分段锁或 CAS（Compare and Swap）算法来保证线程...
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
5. **并发容器**：Java集合框架中的一些类如ConcurrentHashMap、CopyOnWriteArrayList等，是为并发环境设计的。研究这些容器的源码，有助于理解它们在并发访问下的性能和安全性。 6. **死锁、活锁与饥饿**：并发...
并发容器和线程池，java并发编程3
04-29
`Future`接口提供了获取异步计算结果的能力，它是Java并发编程中重要的API之一。 ##### 3.1 FutureTask `FutureTask`是`Future`接口的一个具体实现，它可以包装一个`Runnable`或`Callable`对象，并允许用户获取...
Java并发编程---并发队列
LeoByte的编程驿站
01-31 2049
并发队列 在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列非阻塞队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。 阻塞队列与非阻塞队 阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程...
并发编程-并发机制的底层实现原理pdf篇
m0_67322837的博客
04-19 175
ava 代码在编译后变成 Java 字节码，字节码被类加载器加载到 JVM里执行，最终转换为汇编指令在CPU上执行，Java 中所所使用的并发机制依赖于 JVM 的实现和 CPU 指令；Java 中的大部分并发容器和框架依赖于 volatile 和原子操作的实现原理，了解这些原理对我们进行并发编程会有所帮助。 本文将依次介绍：CPU术语、Java对象头、锁的升级与对比、volatile 实现原理、synchronized 实现原理、原子操作的实现原理。 CPU术语 Java对象头 如...
智慧建造总体策划方案（76页）.pptx
11-02
智慧建造总体策划方案（76页）
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件
最新发布
11-02
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件，已在 windows、deepin linux 和树莓派上测试！
LLC simulink仿真《slx模型文件》
11-02
LLC simulink仿真《slx模型文件》 LLC谐振转换器是一种高效的直流-直流(DC-DC)电源转换器，因其独特的谐振特性而得名。在电力电子领域，LLC仿真对于理解和优化这种转换器的性能至关重要。Simulink是MATLAB环境下的一个强大工具，用于建立和仿真复杂系统，包括电力电子系统。 标题“LLC simulink仿真”指的是使用Simulink进行LLC谐振转换器的建模和仿真。通过Simulink，工程师可以模拟LLC转换器在不同工作条件下的行为，如负载变化、输入电压变动以及控制策略的影响。 **LLC电路的基本原理：** LLC谐振转换器结合了升压（Boost）、降压（Buck）和串联谐振（Series Resonant）三种拓扑结构的特点。它由主开关、副开关、电感、电容和二极管组成。谐振电容和电感形成谐振回路，使得开关器件能在零电压或零电流条件下切换，从而降低开关损耗并提高效率。 **仿真过程：** 在Simulink中，首先需要建立LLC转换器的模型，包括各个元件的参数设定。这包括主开关和副开关的开关频率、谐振电容和电感的值、二极管的反向恢复特性等。然后，设
Java并发编程-并发容器1：关键属性、类和CAS操作详解
Java并发编程中的并发容器是为了解决多线程下数据共享的问题而设计的，其中一个重要的并发容器就是ConcurrentHashMap。在多线程情况下，使用HashMap扩容时会出现CPU接近100%的情况，因为HashMap不是线程安全的；而...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值