JDK容器与并发—List

最新推荐文章于 2024-12-26 09:38:34 发布
原创 最新推荐文章于 2024-12-26 09:38:34 发布 · 559 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#jdk #容器 #并发 #List

博客主要围绕List展开，包含List框架的概览以及不同List之间的比较等信息技术相关内容。

List框架概览


List比较


Java高并发编程实战8，同步容器与并发容器
学Java，找哪吒
06-12 1万+
Java基础教程系列，打造精品专栏。
JDK容器与并发—List—CopyOnWriteArrayList
探索java技术、web技术
04-20 880
概述       俗称读写ArrayList，线程安全的ArrayList版本，其所有写操作都是基于底层数组的副本操作，成功后再替换底层数组，可以理解为基于"snapshot" array的并发，适用于读多写少的并发环境。 1）采用"snapshot"  iterator，在遍历过程中，底层数组是不会修改的，不存在并发干扰，不会抛出ConcurrentModificationException
JDK容器与并发—JDK容器框架
探索java技术、web技术
04-20 1004
本系列文章所讨论的《JDK容器与并发》都是基于jdk 1.7.0_79版本。JDK中涉及的容器及Map框架图如下： Collection（俗称的容器）包括List、Set、Queue，
JDK容器与并发—数据结构
探索java技术、web技术
04-20 3739
若想提高编程水平，一种方式就是看优秀框架的源码，JDK的源码就是一个很好例子，顺便也熟悉一下经常用到的类。在了解过程中，可以了解其框架设计方式，为什么要这样设计。先看看list 的UML类图：
java8并发容器详解之List
2301_79932106的博客
09-23 1144
Vector: 虽然读写方法都加锁了，但是性能比Cow容器要好： 数据复制后，原数组没有变量持有引用，GC时会被回收，频繁导致GC。GC时间过长：并发写性能非常差，读未加锁，高并发读少量写适用： 迭代器相关方法未加锁 如果需要使用迭代器迭代操作，建议使用SynchronizedList，否则Vector和SynchronizedList一样。
同步类容器和并发类容器
热门推荐
yjclsx的博客
07-31 41万+
一.为什么会出现同步容器？ 在Java的集合容器框架中，主要有四大类别：List、Set、Queue、Map。 注意Collection和Map是顶层接口，而List、Set、Queue接口则分别继承了Collection接口，分别代表数组、集合和队列这三大类容器。 像ArrayList、LinkedList都是实现了List接口，HashSet实现了Set接口，而Deque（双向队列，允许...
JDK提供的并发容器总结
thebigdipperbdx的博客
09-09 486
JDK提供的并发容器总结 JDK提供的这些容器大部分在 java.util.concurrent 包中 ConcurrentHashMap: 线程安全的HashMap CopyOnWriteArrayList: 线程安全的List，在读多写少的场合性能非常好，远远好于Vector. ConcurrentLinkedQueue: 高效的并发队列，使用链表实现。可以看做一个线程安全的 LinkedL...
JDK容器与并发—Map—LinkedHashMap
探索java技术、web技术
04-20 1683
概述       用双向链表遍历整个key-value对，顺序为key插入的顺序，不会带来treemap的成本  Map copy = new LinkedHashMap(m); building LRU caches.put get、putall会访问到，不会收到迭代器影响 removeEldestEntry用于清空旧的缓存 其性能较hashmap稍差，应为要维护链表；但是
JDK容器与并发—Map—ConcurrentSkipListMap
探索java技术、web技术
04-20 5442
概述       基于跳表实现的ConcurrentNavigableMap。 1）containsKey、get、put、remove等操作的平均时间复杂度为log(n)；size非固定时间操作，因异步特性，需要遍历所有节点才能确定size，且可能不是正确的值如果遍历过程中有修改；批量操作：putAll、equals、toArray、containsValue、clear非原子性。 2）增
JDK容器与并发—Map—ConcurrentHashMap
探索java技术、web技术
04-20 4415
概述       线程安全的HashMap版本。 1）基本思想：将整个大的hash table进一步细分成小的hash table，即Segment； 2）读不用加锁；写操作在所在的Segmenet上加锁，而不是整个HashMap，Hashtable就是所有方法竞争Hashtable上的锁，导致并发效率低； 3）采用懒构造segment（除了segments[0]），以减少初始化内存。
并发编程必备：精通JDK并发容器的使用和策略
逆流的小鱼
05-02 187
并发编程是现代软件开发中不可或缺的一部分，它允许多线程同时访问和修改数据，但这也引入了复杂性，尤其是在容器（如List、Set、Map和Queue）这些共享数据结构的使用上。为了解决并发环境下的竞态条件和数据同步等问题，Java提供了一系列的线程安全容器，即并发容器。
9、并发容器（Map、List、Set）实战及其原理.pdf
02-28
根据提供的文档信息，本文将详细解析并发容器（Map、List、Set）的实战应用及其原理。并发容器在Java多线程环境下发挥着至关重要的作用，它们的设计旨在解决非线程安全容器在高并发场景下的性能瓶颈问题。接下来，...
并发容器（Map、List、Set）实战及其原理分析
Zhuxiaoyu_91的博客
12-26 1343
并发容器（Map、List、Set）实战及其原理分析
JDK容器与并发—Queue—Interface
探索java技术、web技术
04-20 5170
框架概览 接口介绍 Queue       俗称队列，其设计目标是存储处理前的元素。在Collection基础上，新增了入队、出队、访问队首元素的方法： 1）Queue有两套功能相同的方法：add、remove、element分别为入队、出队、访问队首元素方法的抛出异常版本；offer、poll、peek则为返回特殊值的版本： 2）offer在有界队列中常用，当队
JDK容器与并发—Queue—PriorityBlockingQueue
探索java技术、web技术
08-28 2229
概述       基于优先堆的无界阻塞队列，PriorityQueue的线程安全版本。 数据结构       基于数组的平衡二叉堆，在PriorityQueue基础上，增加了一把锁、一个条件： private transient Object[] queue; // 增删查公用的锁 private final ReentrantLock lock; // 队列为空时，阻塞take/po
JDK容器与并发—Queue—LinkedTransferQueue
探索java技术、web技术
08-28 2130
概述       基于单链表的无界传输队列，线程安全。 1）FIFO； 2）size()非固定时间，由于异步特新，若遍历过程有修改，则可能不正确；批量操作addAll、removeAll、retainAll、containsAll、equals、toArray不保证原子性； 3）遵守内存一致性原则。 数据结构       基于单链表： // 队列节点 // 依赖Unsafe机制最小化
JDK容器与并发—Queue—PriorityQueue
探索java技术、web技术
08-28 1349
概述       基于优先堆的无界优先队列，非线程安全。 1）add、offer、remove、poll的时间复杂度为O(log(n))；remove(Object)、contains(Object)为线性时间；peek、element、size为固定时间。 数据结构       基于数组的平衡二叉堆： // queue[n]元素的两个children为queue[2*n+1]、queu
JDK容器与并发—Map—WeakHashMap
探索java技术、web技术
04-20 1112
概述       基于弱引用键实现的HashMap，非线程安全。 1）当key所引用的对象只有弱引用时，在GC回收该对象后，会自动删除所关联的Entry； 2）其行为部分依赖GC； 3）value是强引用的。确保value没有直接或间接引用key，否则会阻止key引用对象的回收。间接引用：value1强引用key2的对象，其所关联的value2强引用key1的对象。 4）迭代器fail-
JDK容器与并发—Map—TreeMap
探索java技术、web技术
04-20 998
概述       基于红黑树的NavigableMap，非线程安全。 1）containsKey、get、put、remove操作的时间复杂度为log(n)； 2）迭代器fail-fast。 数据结构       红黑树： private transient Entry root = null; // 根节点 // tree节点 static final class Entry im
非并发容器与并发容器互转
最新发布
08-08
<think>我们正在讨论非并发容器与并发容器的转换方法及其原理。首先，我们需要明确非并发容器（如ArrayList、HashMap等）和并发容器（如ConcurrentHashMap、CopyOnWriteArrayList等）的设计差异。 非并发容器在并发环境下需要外部同步（例如使用synchronized或ReentrantLock）来保证线程安全。而并发容器内部已经实现了线程安全的机制，可以在多线程环境下直接使用。 转换方法： 1. **非并发容器转并发容器**：通过包装器或直接使用并发容器实现。 - 对于List：可以使用`Collections.synchronizedList`方法将非并发List（如ArrayList）转换为同步List，但这并不是真正的并发容器（它使用同步块）。或者直接使用`CopyOnWriteArrayList`。 - 对于Map：可以使用`Collections.synchronizedMap`将HashMap转换为同步Map，或者直接使用`ConcurrentHashMap`。 2. **并发容器转非并发容器**：通常不推荐，因为并发容器内部机制复杂，直接转换为非并发容器可能失去线程安全特性。但可以通过复制数据的方式，例如将ConcurrentHashMap的所有元素复制到一个新的HashMap中（注意：在复制过程中需要保证没有并发修改，或者使用快照方式）。 原理分析： - **非并发容器转换为同步容器（使用Collections.synchronizedXXX）**： 原理：这些包装器在容器的方法上加上synchronized同步块，使用一个全局锁（mutex）来保证线程安全。例如： ```java // Collections.synchronizedList 源码片段 public E get(int index) { synchronized (mutex) {return list.get(index);} } ``` 缺点：全局锁导致并发性能较低。 - **使用并发容器**： - `CopyOnWriteArrayList`：写操作时复制整个底层数组，读操作无锁。适合读多写少的场景。 - `ConcurrentHashMap`：在JDK1.7中采用分段锁（Segment），在JDK1.8中采用CAS+synchronized（锁单个桶）。 下面我们详细讨论转换方法和原理。 ### 一、非并发容器转换为线程安全容器 #### 1. 使用`Collections.synchronizedXXX`方法 Java提供了一组静态方法，可以将非并发容器包装成同步容器。这些方法包括： - `synchronizedList(List<T> list)` - `synchronizedMap(Map<K,V> m)` - `synchronizedSet(Set<T> s)` **原理**： - 在返回的包装器对象中，每个方法都使用一个互斥锁（mutex）进行同步。默认情况下，互斥锁是包装器对象本身（this）。 - 例如，`synchronizedList`的实现： ```java static class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> { final List<E> list; SynchronizedList(List<E> list) { super(list); this.list = list; } public E get(int index) { synchronized (mutex) { return list.get(index); } } // 其他方法类似，都加上了synchronized块 } ``` **缺点**： - 性能瓶颈：所有操作都需要获取同一把锁，高并发下竞争激烈。 - 迭代器需要外部同步：在迭代时，必须手动对容器加锁，否则可能抛出`ConcurrentModificationException`。 #### 2. 使用并发容器替代 直接使用Java并发包（`java.util.concurrent`）中的容器类： - `List` → `CopyOnWriteArrayList` - `Map` → `ConcurrentHashMap` - `Set` → `CopyOnWriteArraySet` 或 `ConcurrentHashMap.newKeySet()` - `Queue` → `ConcurrentLinkedQueue`, `ArrayBlockingQueue`等 **原理**： - **`CopyOnWriteArrayList`**：写操作（add、set、remove等）通过复制整个数组来实现，写操作在一个锁的保护下进行（保证只有一个写线程），读操作无锁。适用于读多写少的场景[^4]。 ```java // 写操作示例（简化版） public boolean add(E e) { final ReentrantLock lock = this.lock; lock.lock(); try { Object[] elements = getArray(); int len = elements.length; Object[] newElements = Arrays.copyOf(elements, len + 1); newElements[len] = e; setArray(newElements); return true; } finally { lock.unlock(); } } ``` - **`ConcurrentHashMap`（JDK1.8）**：采用数组+链表/红黑树结构，使用CAS和synchronized（锁住单个桶）来实现线程安全。put操作流程如下[^3]： 1. 计算key的hash值。 2. 如果表未初始化，则初始化。 3. 如果定位到的桶为空，则通过CAS尝试插入。 4. 如果桶不为空（有节点），则使用synchronized锁住该桶的第一个节点，然后进行链表或红黑树的插入。 5. 如果链表长度超过8，则转换为红黑树。 6. 如果总元素数量超过阈值，则扩容。 ### 二、并发容器转换为非并发容器 通常没有直接的方法，因为并发容器内部结构复杂，且设计目标就是支持并发。但可以通过以下方式： 1. **复制数据**：在并发容器上获取一个快照，然后复制到一个非并发容器中。例如： ```java Map<K, V> map = new HashMap<>(); concurrentHashMap.forEach((k, v) -> map.put(k, v)); ``` 注意：在复制过程中，如果有并发修改，可能会丢失更新。因此，最好在无并发修改时进行（如暂停写操作）。 2. **使用序列化/反序列化**：将并发容器序列化为字节流，再反序列化为非并发容器（同样要注意数据一致性）。 ### 三、设计思想对比 | 容器类型 | 线程安全实现方式 | 适用场景 | |------------------|------------------------------|------------------------------| | 同步包装容器 | 方法级synchronized（全局锁） | 低并发，简单场景 | | `CopyOnWriteArrayList` | 写时复制（复制整个数组） | 读多写少，读操作要求快速响应 | | `ConcurrentHashMap` | CAS + 桶锁（synchronized） | 高并发读写 | > **转换建议**： > - 需要线程安全且性能要求高 → 直接使用并发容器（如`ConcurrentHashMap`） > - 兼容旧代码且并发压力小 → 使用`Collections.synchronizedXXX` > - 不需要线程安全 → 直接使用非并发容器（但需确保单线程环境） ### 总结 非并发容器与并发容器的转换本质上是线程安全机制的转换。转换方法包括： 1. **升级为线程安全**： - 通过包装器（`Collections.synchronizedXXX`）添加全局锁。 - 替换为并发容器（如`ConcurrentHashMap`、`CopyOnWriteArrayList`）。 2. **降级为非线程安全**：通过复制数据创建非并发容器副本。 选择哪种方式取决于具体场景： - 并发性能要求高 → 并发容器。 - 需要简单同步 → 包装器。 - 单线程使用 → 非并发容器。 --- §§相关问题§§ 1. `Collections.synchronizedList` 和 `CopyOnWriteArrayList` 在性能上有何差异？ 2. `ConcurrentHashMap` 在 JDK1.7 和 JDK1.8 中的实现原理有何不同？ 3. 如何选择 `ConcurrentHashMap` 和 `Hashtable`？ 4. `CopyOnWriteArrayList` 的写时复制机制在哪些场景下不适用？</think>### 非并发容器与并发容器的转换方法及原理 Java 容器分为非并发容器（`java.util`）和并发容器（`java.util.concurrent`）。二者转换的核心是**通过同步机制实现线程安全**或**利用并发容器替代非并发容器**。以下是转换方法与原理分析： --- #### 一、非并发容器 → 并发安全的容器 ##### 1. **外部同步包装（显式加锁）** **方法**：使用 `synchronized` 或 `ReentrantLock` 包装非并发容器的操作。 **原理**： - 通过互斥锁保证同一时刻只有一个线程操作容器。 - 示例： ```java List<String> syncList = Collections.synchronizedList(new ArrayList<>()); // 包装为同步List[^1] Map<K,V> syncMap = Collections.synchronizedMap(new HashMap<>()); ``` **源码分析**（以 `Collections.synchronizedList` 为例）： ```java public boolean add(E e) { synchronized (mutex) { // 全局锁（mutex = this） return list.add(e); // 委托给原始ArrayList } } ``` **缺点**： - 全局锁导致并发性能低（所有操作串行化）[^1]。 - 迭代器需手动同步，否则可能抛出 `ConcurrentModificationException`。 ##### 2. **写时复制（Copy-On-Write）** **方法**：将非并发容器替换为 `CopyOnWriteArrayList` 或 `CopyOnWriteArraySet`。 **原理**： - **读操作**：无锁访问原数组（快照）。 - **写操作**：复制新数组修改，替换旧引用（加锁保证原子性）[^4]。 **数据结构**： ```java // CopyOnWriteArrayList 核心字段 final transient ReentrantLock lock = new ReentrantLock(); private transient volatile Object[] array; // volatile保证可见性 ``` **操作流程**： ```java public boolean add(E e) { final ReentrantLock lock = this.lock; lock.lock(); // 加锁 try { Object[] elements = getArray(); Object[] newElements = Arrays.copyOf(elements, len + 1); // 复制新数组 newElements[len] = e; setArray(newElements); // volatile写替换引用 return true; } finally { lock.unlock(); } } ``` **适用场景**：读多写少（如监听器列表）。 --- #### 二、并发容器 → 非并发容器 ##### 1. **数据迁移（快照复制）** **方法**：将并发容器的数据复制到非并发容器。 **原理**： - 利用并发容器的原子快照（如 `ConcurrentHashMap.keySet()` 或 `CopyOnWriteArrayList` 的数组）。 - 示例： ```java ConcurrentHashMap<String, Integer> concurrentMap = ...; HashMap<String, Integer> hashMap = new HashMap<>(concurrentMap); // 复制构造 ``` **注意**： - 复制过程非原子，可能丢失实时更新。 - 适用于只读场景或低一致性要求。 ##### 2. **单线程环境降级** **方法**：在确认单线程访问时直接使用并发容器。 **原理**： - 并发容器（如 `ConcurrentHashMap`）在单线程下无锁竞争开销。 - 性能与非并发容器接近（JDK8 优化了 `ConcurrentHashMap` 的内存布局）。 --- #### 三、并发容器替代方案（推荐） 直接使用并发容器替代非并发容器，无需转换： | 非并发容器 | 并发容器替代品 | 实现原理 | |----------------|---------------------------|-----------------------------| | `ArrayList` | `CopyOnWriteArrayList` | 写时复制 + ReentrantLock | | `HashMap` | `ConcurrentHashMap` | CAS + synchronized 桶锁[^3] | | `HashSet` | `ConcurrentHashMap.KeySet` | 委托给ConcurrentHashMap | | `LinkedList` | `ConcurrentLinkedQueue` | CAS 无锁队列 | ##### `ConcurrentHashMap` 原理（JDK8）[^3] **数据结构**： - 数组 + 链表/红黑树（同 `HashMap`）。 **线程安全机制**： - **CAS**：初始化数组、插入空桶等。 - **synchronized**：锁定哈希冲突的桶（链表头节点）。 **put 流程**： 1. 计算哈希，定位桶位置。 2. 桶为空 → CAS 插入。 3. 桶非空 → `synchronized` 锁住头节点： - 链表 → 遍历插入/更新 - 红黑树 → 树节点插入 4. 链表长度 ≥ 8 → 树化。 --- ### 设计思想对比 | **方案** | **原理** | **性能** | **适用场景** | |--------------------|------------------------------|---------------|---------------------| | 外部同步包装 | 全局锁（synchronized） | 低并发 | 简单同步需求 | | 写时复制 | 读无锁 + 写复制数组 | 读极高，写极低 | 读多写少（如配置） | | `ConcurrentHashMap`| CAS + 桶级锁 | 高并发 | 高频读写键值对 | | 数据迁移 | 原子快照复制 | 一次性开销 | 只读数据导出 | --- ### 关键问题解答 #### 1. 为什么推荐直接使用并发容器？ - **安全**：内置线程安全机制，避免手动同步错误。 - **性能**：并发容器优化了锁粒度（如 `ConcurrentHashMap` 的桶锁）。 - **功能**：提供原子方法（如 `ConcurrentHashMap.putIfAbsent()`）。 #### 2. 如何选择转换方案？ - 需要兼容旧代码 → 外部同步包装。 - 高频读、低频写 → `CopyOnWriteArrayList`。 - 高频读写 → `ConcurrentHashMap`。 - 数据归档 → 快照复制到非并发容器。 > **最佳实践**： > - 新项目优先使用 `java.util.concurrent` 容器。 > - 转换时测试并发场景下的性能和数据一致性。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值