【Java 基础】Java 并发集合容器

ゝ一世哀愁。 2024-05-04 08:04 160阅读 0赞

![在这里插入图片描述][387f1864cd90449db1f9ef5a10974651.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 进阶之路][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  一、ConcurrentHashMap
         *  二、CopyOnWriteArrayList
         *  三、CopyOnWriteArraySet

#### 一、ConcurrentHashMap ####

ConcurrentHashMap是Java中的一个线程安全的哈希表实现，它是HashMap的线程安全版本。与HashMap不同的是，ConcurrentHashMap可以在多线程环境下安全地进行读写操作，而不需要额外的同步机制。

ConcurrentHashMap的主要特点包括：

1.  **分段锁**：ConcurrentHashMap内部将数据分成了多个段（Segment），每个段维护了一个独立的哈希表，不同的线程可以同时访问不同的段，从而提高了并发性能。每个段的大小可以通过调整ConcurrentHashMap的并发级别来设置，默认为16。
2.  **线程安全**：ConcurrentHashMap使用了一种细粒度的锁机制，通过对每个段进行加锁，实现了线程安全的并发访问。
3.  **高效的读操作**：ConcurrentHashMap的读操作不需要加锁，可以并发进行，因此读操作的性能非常高。

下面是一个使用ConcurrentHashMap的简单示例：

import java.util.concurrent.ConcurrentHashMap;
    
    public class ConcurrentHashMapExample {
        
        public static void main(String[] args) {
        
            ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
             // 向ConcurrentHashMap中添加元素
            map.put("A", 1);
            map.put("B", 2);
            map.put("C", 3);
             // 获取元素
            System.out.println("Value of A: " + map.get("A"));
             // 替换元素
            map.replace("B", 4);
             // 删除元素
            map.remove("C");
             // 遍历元素
            for (String key : map.keySet()) {
        
                System.out.println("Key: " + key + ", Value: " + map.get(key));
            }
        }
    }

在这个示例中，我们创建了一个ConcurrentHashMap对象，并向其中添加了一些键值对。然后，我们通过get方法获取键为"A"的值，并使用replace方法替换键为"B"的值。最后，我们使用remove方法删除键为"C"的元素，并通过遍历ConcurrentHashMap来打印所有的键值对。

需要注意的是，虽然ConcurrentHashMap是线程安全的，但并不保证对于所有操作的原子性。如果需要保证原子性，可以使用ConcurrentHashMap提供的原子操作方法，如putIfAbsent、remove等。

总结来说，ConcurrentHashMap是一个高效的线程安全哈希表实现，适用于多线程环境下的并发访问。它提供了高效的读操作和线程安全的写操作，可以作为HashMap的替代品在多线程环境下使用。

#### 二、CopyOnWriteArrayList ####

CopyOnWriteArrayList是Java中的一个线程安全的List实现，它是ArrayList的线程安全版本。与ArrayList不同的是，CopyOnWriteArrayList通过在修改操作时创建一个新的副本来实现线程安全，而不是使用锁机制进行同步。

CopyOnWriteArrayList的主要特点包括：

1.  写操作的安全性：CopyOnWriteArrayList通过创建一个新的副本来实现写操作的线程安全性。当有线程进行写操作时，会先将原始数据复制一份，并在副本上进行修改，然后将副本替换原始数据。这样做的好处是读操作不需要加锁，因此读操作的性能非常高。
2.  读操作的性能：由于读操作不需要加锁，多个线程可以同时读取CopyOnWriteArrayList中的数据，因此读操作的性能非常高。
3.  内存占用：由于每次写操作都会创建一个新的副本，因此CopyOnWriteArrayList的内存占用较高。如果数据量较大或写操作频繁，可能会导致内存消耗过大。  
    下面是一个使用CopyOnWriteArrayList的简单示例：

import java.util.concurrent.CopyOnWriteArrayList;
    
    public class CopyOnWriteArrayListExample {
        
        public static void main(String[] args) {
        
            CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
             // 向CopyOnWriteArrayList中添加元素
            list.add("A");
            list.add("B");
            list.add("C");
             // 遍历元素
            for (String element : list) {
        
                System.out.println("Element: " + element);
            }
             // 修改元素
            list.set(1, "D");
             // 删除元素
            list.remove(2);
             // 遍历修改后的元素
            for (String element : list) {
        
                System.out.println("Element: " + element);
            }
        }
    }

在这个示例中，我们创建了一个CopyOnWriteArrayList对象，并向其中添加了一些元素。然后，我们通过遍历CopyOnWriteArrayList来打印所有的元素。接着，我们使用set方法修改索引为1的元素，并使用remove方法删除索引为2的元素。最后，我们再次遍历CopyOnWriteArrayList来打印修改后的元素。

需要注意的是，由于CopyOnWriteArrayList在修改操作时会创建一个新的副本，因此对于大型数据集或频繁的写操作，CopyOnWriteArrayList可能不是最佳选择，因为它会消耗大量的内存和CPU资源。

总结来说，CopyOnWriteArrayList是一个线程安全的List实现，适用于多线程环境下的并发访问。它通过在修改操作时创建一个新的副本来实现线程安全，读操作的性能较高。然而，由于每次写操作都会创建一个新的副本，可能会消耗大量的内存和CPU资源，因此在某些场景下需要谨慎使用。

#### 三、CopyOnWriteArraySet ####

CopyOnWriteArraySet是Java中的一个线程安全的Set实现，它是CopyOnWriteArrayList的Set版本。它与HashSet不同的是，CopyOnWriteArraySet通过在修改操作时创建一个新的副本来实现线程安全，而不是使用锁机制进行同步。

CopyOnWriteArraySet的主要特点包括：

1.  写操作的安全性：CopyOnWriteArraySet通过创建一个新的副本来实现写操作的线程安全性。当有线程进行写操作时，会先将原始数据复制一份，并在副本上进行修改，然后将副本替换原始数据。这样做的好处是读操作不需要加锁，因此读操作的性能非常高。
2.  读操作的性能：由于读操作不需要加锁，多个线程可以同时读取CopyOnWriteArraySet中的数据，因此读操作的性能非常高。
3.  内存占用：由于每次写操作都会创建一个新的副本，因此CopyOnWriteArraySet的内存占用较高。如果数据量较大或写操作频繁，可能会导致内存消耗过大。

下面是一个使用CopyOnWriteArraySet的简单示例：

import java.util.concurrent.CopyOnWriteArraySet;
    
    public class CopyOnWriteArraySetExample {
        
        public static void main(String[] args) {
        
            CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();
             // 向CopyOnWriteArraySet中添加元素
            set.add("A");
            set.add("B");
            set.add("C");
             // 遍历元素
            for (String element : set) {
        
                System.out.println("Element: " + element);
            }
             // 修改元素（CopyOnWriteArraySet不支持修改操作，会抛出UnsupportedOperationException异常）
            // set.set(1, "D");
             // 删除元素
            set.remove("B");
             // 遍历修改后的元素
            for (String element : set) {
        
                System.out.println("Element: " + element);
            }
        }
    }

在这个示例中，我们创建了一个CopyOnWriteArraySet对象，并向其中添加了一些元素。然后，我们通过遍历CopyOnWriteArraySet来打印所有的元素。接着，我们尝试使用set方法修改元素，但由于CopyOnWriteArraySet不支持修改操作，所以会抛出UnsupportedOperationException异常。最后，我们使用remove方法删除了元素，并再次遍历CopyOnWriteArraySet来打印修改后的元素。

需要注意的是，由于CopyOnWriteArraySet在修改操作时会创建一个新的副本，因此对于大型数据集或频繁的写操作，CopyOnWriteArraySet可能不是最佳选择，因为它会消耗大量的内存和CPU资源。

总结来说，CopyOnWriteArraySet是一个线程安全的Set实现，适用于多线程环境下的并发访问。它通过在修改操作时创建一个新的副本来实现线程安全，读操作的性能较高。然而，由于每次写操作都会创建一个新的副本，可能会消耗大量的内存和CPU资源，因此在某些场景下需要谨慎使用。

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[387f1864cd90449db1f9ef5a10974651.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/3b495e685cb641da9aa29cc859b4843f.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center