Java常用并发容器（concurrent包）

最新推荐文章于 2022-07-29 17:44:12 发布
最新推荐文章于 2022-07-29 17:44:12 发布
阅读量317 收藏
点赞数
分类专栏： Java多线程 Java高并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17305249/article/details/77807674
版权
各种并发容器：
Map
    HashTable
    HashMap ( Collections.synchronizedMap(Map<?,?> map) )
    ConcurrentHashMap
    ConcurrentSkipListMap
List
    CopyOnWriteList
    
性能比较：
需求：100个线程，每个线程往容器里放10000个数据，比较线程执行时间长短。

1.HashTable（相当于把hashMap的方法加锁，效率低）
1 
public class TestHashTable{
2 
    public static void main(String[] args){
3 
        Map<String, String> map = new HashTable<>();//初始化容器
4 
    
5 
        Random r = new Random();
6 
        Thread[] threads = new Thread[100];//线程数组放100个线程
7 
        CountDownLatch latch = new CountDownLatch(this.length);
8 
        long start = System.currentTimeMillis();//----------------记录线程起始时间
9 
        for(int i=0;i<threads.length;i++){
10 
            threads[i] = new Threads(()->{
11 
                for(int j=0;j<10000;j++) map.put("key",r.nextInt(10000));//100个线程每个线程往容器放10000个数据
12 
                latch.countDown();//门栓计数器减1，当100个线程都结束时，门栓技术器为0，唤醒主线程打印
13 
            });
14 
        }
15 
        for(Thread t : threads){
16 
            t.start();//开启100个线程
17 
        }
18 
        try{
19 
            latch.await();//等待100个子线程执行完被唤醒
20 
        }catch(InterruptException e){
21 
            e.printStackTrace();
22 
        }
23 
        long end = System.currentTimeMillis();//-----------------------------记录结束时间
24 
        System.out.println("共耗时：" + end - start);
25 
    }
26 
    
27 
}
28 
//实验结果700+ms
2. ConcurrentHashMap（效率高）
1 
public class TestConcurrentHashMap{
2 
    public static void main(String[] args){
3 
        Map<String, String> map = new ConcurrentHashMap<>();//初始化容器
4 
    
5 
        Random r = new Random();
6 
        Thread[] threads = new Thread[100];//线程数组放100个线程
7 
        CountDownLatch latch = new CountDownLatch(this.length);
8 
        long start = System.currentTimeMillis();//----------------记录线程起始时间
9 
        for(int i=0;i<threads.length;i++){
10 
            threads[i] = new Threads(()->{
11 
                for(int j=0;j<10000;j++) map.put("key",r.nextInt(10000));//100个线程每个线程往容器放10000个数据
12 
                latch.countDown();//门栓计数器减1，当100个线程都结束时，门栓技术器为0，唤醒主线程打印
13 
            });
14 
        }
15 
        for(Thread t : threads){
16 
            t.start();//开启100个线程
17 
        }
18 
        try{
19 
            latch.await();//等待100个子线程执行完被唤醒
20 
        }catch(InterruptException e){
21 
            e.printStackTrace();
22 
        }
23 
        long end = System.currentTimeMillis();//-----------------------------记录结束时间
24 
        System.out.println("共耗时：" + end - start);
25 
    }
26 
    
27 
}
28 
//实验结果610ms
ConcurrentHashMap比HashTable效率高的原因：
HashTable：每次锁定的是整存储数据的数组（增加删除数据串行执行，不能同时操作多个数据）
ConcurrentHashMap：每次只锁定存储数组的一段（将数组分成16段锁定，细化了锁粒度），可同时操作多个数据。


3.ConcurrentSkipListMap跳表map（高并发且排序，插入效率低，查询效率高）
1 
public class TestConcurrentSkipListMap{
2 
    public static void main(String[] args){
3 
        Map<String, String> map = new ConcurrentSkipListMap<>();//初始化容器
4 
    
5 
        Random r = new Random();
6 
        Thread[] threads = new Thread[100];//线程数组放100个线程
7 
        CountDownLatch latch = new CountDownLatch(this.length);
8 
        long start = System.currentTimeMillis();//----------------记录线程起始时间
9 
        for(int i=0;i<threads.length;i++){
10 
            threads[i] = new Threads(()->{
11 
                for(int j=0;j<10000;j++) map.put("key",r.nextInt(10000));//100个线程每个线程往容器放10000个数据
12 
                latch.countDown();//门栓计数器减1，当100个线程都结束时，门栓技术器为0，唤醒主线程打印
13 
            });
14 
        }
15 
        for(Thread t : threads){
16 
            t.start();//开启100个线程
17 
        }
18 
        try{
19 
            latch.await();//等待100个子线程执行完被唤醒
20 
        }catch(InterruptException e){
21 
            e.printStackTrace();
22 
        }
23 
        long end = System.currentTimeMillis();//-----------------------------记录结束时间
24 
        System.out.println("共耗时：" + end - start);
25 
    }
26 
    
27 
}
28 
//实验结果1000+ms
4.CopyOnWriteList（ 写时复制。添加元素--》复制容器---》容器2为新容器（带有插入的新数据），容器1为旧容器，此时另一个线程读数据读的是容器1的数据，不需要加锁） 读的效率高，写的效率低
1 
public class TestCopyOnWriteList{
2 
    public static void main(String[] args){
3 
        List<String> list = new CopyOnWriteList<>();//初始化容器
4 
    
5 
        Random r = new Random();
6 
        Thread[] threads = new Thread[100];//线程数组放100个线程
7 
        CountDownLatch latch = new CountDownLatch(this.length);
8 
        long start = System.currentTimeMillis();//----------------记录线程起始时间
9 
        for(int i=0;i<threads.length;i++){
10 
            threads[i] = new Threads(()->{
11 
                for(int j=0;j<1000;j++) list.add("key"+r.nextInt(10000));//100个线程每个线程往容器放1000个数据
12 
                latch.countDown();//门栓计数器减1，当100个线程都结束时，门栓技术器为0，唤醒主线程打印
13 
            });
14 
        }
15 
        for(Thread t : threads){
16 
            t.start();//开启100个线程
17 
        }
18 
        try{
19 
            latch.await();//等待100个子线程执行完被唤醒
20 
        }catch(InterruptException e){
21 
            e.printStackTrace();
22 
        }
23 
        long end = System.currentTimeMillis();//-----------------------------记录结束时间
24 
        System.out.println("共耗时：" + end - start);//计算运行时间
25 
        System.out.println("数组大小：" + list.size());//100000
26 
    }
27 
    
28 
}
29 
//实验结果5600+ms

rootlh;
关注
专栏目录
并发容器类-Conconcurrent容器原理
弦月的博客
02-08 427
HashMap 数据结构：数组{链表，链表，链表} JDK1.8之后对于HashMap进行了优化 1.8结构 初始时：数组{链表，链表，链表} 当链表增长到8个元素时链表转化为红黑树：数组{链表（–&amp;amp;amp;amp;amp;gt;红黑树）链表（–&amp;amp;amp;amp;amp;gt;红黑树）} HashMap初始化 hashMap初始化的时候会构建存储大小的阈值和扩容临界值，当hashmap大小接近阈值时，就会进行扩容，hashmap的大小是2的幂数.
Java多线程编程中的两种常用并发容器讲解
09-03
Java并发编程中，ConcurrentHashMap和CopyOnWriteArrayList是两种常用的并发容器，它们设计的目标是在多线程环境下提供高效且安全的数据访问。这里主要聚焦于ConcurrentHashMap的讲解。 **ConcurrentHashMap概述** ...
探索JAVA并发 - 并发容器全家福！
架构师小秘圈
08-26 1237
作者：acupt，专注Java，架构师社区合伙人！14个并发容器，你用过几个？不考虑多线程并发的情况下，容器类一般使用ArrayList、HashMap等线程不安全的类，...
Java Concurrent包下的并发容器
一叶吴舟
07-23 336
ConcurrentHashMap  我们知道HashMap不是一个线程安全的容器，最简单的方式使HashMap变成线程安全就是使用Collections.synchronizedMap，它是对HashMap的一个包装 public static Map m=Collections.synchronizedMap(new HashMap()); 同理对于List，Set也提供了相似方法。
Java常用并发容器总结(二)
weixin_34452850的博客
03-31 550
Java常用并发容器总结(二)ConcurrentHashMap1.介绍ConcurrentHashMap是一个高效并发的HashMap,它采用了减小锁粒度的手段，内部进一步细分成了若干个小的HashMap,称为Segment段。默认情况下，一个ConcurrentHashMap被分为16个段。多ConcurrentHashMap操作时，并不是将整个ConcurrentHashMap加锁，而是首先根
14个Java并发容器，你用过几个？
淡定_蜗牛的博客
10-15 272
不考虑多线程并发的情况下，容器类一般使用 ArrayList、HashMap 等线程不安全的类，效率更高。在并发场景下，常会用到 ConcurrentHashMap、ArrayBlockingQueue 等线程安全的容器类，虽然牺牲了一些效率，但却得到了安全。 上面提到的线程安全容器都在 java.util.concurrent 包下，这个包下并发容器不少，今天全部翻出来鼓捣一下。 仅做简单介绍，...
Java-并发（Concurrent）编程
07-15
5. **Java并发工具包(JUC)**：包括原子类、并发容器（如`ConcurrentHashMap`）、阻塞队列（如`ArrayBlockingQueue`）以及锁机制。 6. **Lock和AQS**：Lock接口提供了比`synchronized`更灵活的锁机制，而...
Java 常见并发容器总结
最新发布
07-20
Java 常见并发容器总结 JDK 提供的这些容器大部分在 `java.util.concurrent` 包中。 - **`ConcurrentHashMap`** : 线程安全的 `HashMap` - **`CopyOnWriteArrayList`** : 线程安全的 `List`，在读多写少的场合性能...
Java从同步容器到并发容器的操作过程
08-26
Java 1.5引入的并发容器（集中在`java.util.concurrent`包下）旨在解决这些问题。其中，`CopyOnWriteArrayList`和`CopyOnWriteArraySet`是典型的写时复制（Copy-On-Write，COW）容器，它们在写操作时创建容器副本，...
java并发工具包 java.util.concurrent中文版pdf
06-25
### Java并发工具包 `java.util.concurrent` 知识点详解 #### 一、引言 随着多核处理器的普及和应用程序复杂度的增加，多线程编程成为了现代软件开发不可或缺的一部分。为了简化并发编程的复杂性，Java 5 引入了 `...
并发环境下的常用容器类
ITgagaga的博客
09-14 243
并发环境下的常用容器类 文章目录并发环境下的常用容器类一：常用七大并发容器类二：并发环境中List接口下容器的替代容器1.ArrayList1). 出现异常：2). 解决方法：2.1 使用Vector2.2 使用使用容器工具类下 Collections.synchronizedList(new ArrayList<>())/Collections.synchronizedSet(new HashSet<>())2.3 使用写时复制 new CopyOnWriteArrayList(
常见的并发容器
HungryAndHumble的博客
07-15 403
常见的并发容器
Java Concurrent -- 同步容器类
霍淇滨的博客
05-09 96
同步容器类 同步容器类包括Vector和Hashtable，其外还包括一些由Collections。synchronizedXxx()等工厂方法创建的同步封装器类。这些类实现线程安全的方式是：将他们的状态封装起来，并对每个公有方法都进行同步，使得每次只有一个线程能够访问容器的状态。 同...
Java常用并发容器总结(一)
weixin_34452850的博客
03-31 641
使用Collections工具类对集合进行同步包装1.介绍众所周知，ArrayList、HashMap等类是线程不安全的，在高并发场景下无法使用。解决这个问题的办法之一是使用Collections工具类的synchronizedMap和synchronizedList等方法，将集合包装成线程安全的。2.代码分析以synchronizedMap方法为例，分析其具体实现 //SynchronizedMa
并发编程学习笔记 之 常用并发容器的概念及使用方法
向心行者
07-29 508
所有线程对该容器的读取操作将不会对数据集合产生加锁的动作，从而使得高并发高吞吐量的读取操作变得高效，但是当有线程对该容器中的数据集合进行删除或增加等写操作时才会对整个数据集合进行加锁操作，然后将容器中的数据集合复制一份，并且基于最新的复制进行删除或增加等写操作，当写操作执行结束以后，将最新复制的数据集合引用指向原有的数据集合，进而达到读写分离最终一致性的目的。并发容器是指在高并发应用程序的使用过程中，这些容器（数据结构）是线程安全的，而且在高并发的程序中运行它们会有高效的性能表现。...
Java常用并发容器总结(四)
weixin_34452850的博客
03-31 348
ConcurrentSkipListMap1.介绍跳表是一种可以用来快速查找的数据结构，类似于平衡树，他们都可以对元素进行快速的查找。但一个重要的区别是：对平衡树的插入往往可能导致平衡树进行一次全局的调整；而对跳表的插入和删除之需要的局部数据操作即可。这样的好处是，在高并发环境下，对平衡树的操作需要一个全局锁来保证线程安全，但是对于跳表则只需要部分锁，这样会拥有更好地性能。 就查询的性能而言，跳表
Java常用并发容器总结(三)
weixin_34452850的博客
03-31 368
CopyOnWriteArrayList1.介绍CopyOnWriteArrayList可以理解为一个线程安全的List,它的实现原理是：在写入操作时，进行一次自我复制。也就是说，对于CopyOnWriteArrayList的读操作，不加任何同步处理；当需要进行修改操作时，对原有的数据进行一次复制，将修改的内容写入副本中。写完之后，再用修改后的副本替换原来的数据。这样一来，写操作与读操作之间互不影响
Java Concurrent--并发容器类
霍淇滨的博客
05-27 104
并发容器类图 Queue Queue上的操作不会阻塞，如果队列为空，那么获取元素的操作将返回空值。虽然可以使用List来模拟Queue的行为--事实上正是通过LinkedList来实现Queue的，但Queue能够去掉List的随机访问请求，实现更高效的并发。 Queue有几种实...
常用并发工具、并发容器（并发编程篇）
qq_30364247的博客
05-25 354
jdk-api中文手册 常用的并发辅助工具类 CountDownLatch：允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。 可以理解为：统计xx-x的航班票数，必须等到多个航空公司（多线程）都统计完成后才能汇总展示给用户。 用法：CountDownLatch latch=new CountDownLatch(number)，先初始化一个number；再多线程情况下 每调用一次countDown()方法，计数-1直到number为0时，再配合await()使用；如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值