CopyOnWriteArrayList引发OOM

最新推荐文章于 2025-05-27 15:17:59 发布
原创 最新推荐文章于 2025-05-27 15:17:59 发布 · 2.7k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#servlet #数据结构 #jboss #apache

服务突然在23号出现异常，响应时间最长达到60几秒，原因是使用了不适合频繁读写操作的CopyOnWriteArrayList数据结构，导致Apache与Jboss之间大量连接超时并引发内存溢出。

正常一年多的一个服务突然在23号出现异常，响应最快的竟然达到60几秒。apache与jboss之间大量连接超时。

看异常日志，发现竟然有一个新上的Servlet出现OOM。

review该Servlet,发现竟然用了一个CopyOnWriteArrayList来存放大量写和读和临时数据，该数据结构只适合偶尔写大量读的情况，

否则会造成不停地COPY空间，从而导致OOM

 

 

探索Java并发容器的深坑与妙用：从同步到并发的进化之路
码上代码的博客
06-12 504
Java并发容器为我们提供了丰富的选择，但每种容器都有其适用的场景和注意事项。在实际工作中，理解这些容器的特性，选对容器，才能真正发挥它们的优势，写出高效、安全的并发程序。希望这篇文章能帮助你在并发编程的道路上走得更远，少踩坑，多收获。如果你有任何疑问或经验分享，欢迎在评论区留言讨论。让我们一起探索Java并发编程的奥秘！
【性能调优】调优的常见思路和方法
sysu_lluozh
03-04 2811
本文总结了性能调优的系统性方法，从代码、CPU、内存等方面提供可落地的优化套路。在代码层面，重点关注正则表达式、日志输出、锁优化等高频问题点；CPU问题需区分高负载和高利用率场景，结合线程堆栈和GC情况分析；内存问题则需系统排查堆内存、堆外内存及系统内存使用情况，识别内存泄漏和溢出原因。文章强调复杂问题可能有简单解，优化应遵循空间换时间、并行化等核心思路，避免盲目使用缓存、异步等技术。
CopyOnWriteArrayList
anblic的博客
03-06 1803
机制实现了读操作的无锁并发，适合读多写少的高并发场景，但其写操作的高内存开销和弱一致性特点需谨慎评估。在实际应用中，需结合业务需求权衡性能与一致性，合理选择并发容器。
【Java并发编程】并发容器之CopyOnWriteArrayList
05-15 997
问题是什么？ArrayList 在使用iterator的时候会遇到ConcurrentModificationException的异常，就是由于遍历的时候，又进行写操作。 解决办法就是:可以通过同步锁来限制它们同时发生。自己加锁有些麻烦，有现成的方案吗？CopyOnWriteArrayList来看看其add方法：public synchronized boolean add(E e) {
关于Java中CopyOnWriteArrayList的一些问题
trayvontang的博客
01-23 880
文章目录1. 开始2. CopyOnWriteArrayList3. 回到开始 1. 开始 假设有一个游戏服务，需要和客户端相互发送数据。 如果是你，你会怎么设计这个结构和逻辑。 我们还是先来看一个简化抽象版容易劝退的实际例子，当然这个例子不重要，完全可以跳过。 不过可以检查一下你对Java并发的熟悉程度，你能发现的问题也多，说明你对Java并发也了解。 因为下面的代码示例反应了很多朋友对多线程的理解的感觉。 这种感觉怎么说呢？不是不懂，各种JUC的工具感觉也熟悉，自己用着程序好像也没啥问题。 但是是总感觉
并发容器
程序员小潘
11-26 3198
List、Map、Set，我们经常使用这些容器来存放数据，以及对数据进行增删改查。 但有一点需要注意的是：java.util包下的很多容器都是线程不安全的。 解决的办法就是使用synchronized和显式锁来保证线程安全，但是这么做太麻烦了，效率也很低。 JDK为我们提供了一些线程安全的并发容器，可以直接使用，不用我们自己来维护并发问题。 List CopyOnWriteArrayList 实现...
67. CopyOnWriteArrayList 使用场景
weixin_43484713的博客
05-27 1672
CopyOnWriteArrayList是Java并发包中的线程安全List实现，采用写时复制机制保证线程安全。其核心特点是读操作无锁且高效，写操作通过复制数组副本来避免并发问题，适合读多写少场景。底层基于volatile数组，写操作需加锁并复制整个数组，内存开销较大。与ArrayList相比，它牺牲写性能换取线程安全和读操作高效性，迭代器具有弱一致性。典型应用包括事件监听器、只读缓存和高并发读取的低频更新场景，但不适合频繁修改或强一致性要求的场景。
VAGAA内存占用异常分析：GC机制缺失引发的6种资源泄漏模式实录
它没有崩溃于复杂的网络协议，也没有败给安全机制，而是倒在了最基础的资源管理上：持续48小时后内存从150MB飙升至1.2GB以上，最终因OOM（Out of Memory）退出。 这背后，是一场关于“谁该为内存负责”的哲学之争。...
【Java并发编程】面试题
Stay Hungry, Stay Foolish!
10-10 1755
文章目录并发编程基础为什么有多线程守护线程是什么线程的生命周期Runnable和Callable区别run()与start()方法区别wait方法和sleep方法的区别Thread.interrupt() 方法的工作原理什么是线程上下文切换可见性、原子性、有序性问题产生原因线程安全相关volatile原理happens-before原则是什么synchronized原理synchronized与Lock区别Java中如何进行锁优化Java 锁升级过程死锁、活锁、饥饿区别乐观锁与悲观锁公平锁与非公平锁可重入锁
Java 高考信息管理系统 SQL数据库
11-07
Java 高考信息管理系统 SQL2000数据库，一个Java与数据库结合的小例子，可以学到一些窗体的知识，不过更多的则是Java与数据库方面的基础操作，比如添加、修改数据、管理数据等，初学者可通过这个范例学习一些数据库的操作知识。
java面试（多线程）
11-10 1572
线程安全 && 线程不安全线程安全 - 如果线程执行过程中不会产生共享资源的冲突，则线程安全线程不安全 - 如果有多个线程同时在操作主内存中的变量，则线程不安全实现线程安全的三种方式java线程安全有哪些实现思路?_价值成长的博客-优快云博客在并发编程中分析线程安全的问题时往往需要切入点，那就是两大核心：JMM抽象内存模型以及happens-before规则，三条性质：原子性，有序性和可见性。12.1 原子性。
CopyOnWriteArrayList的缺陷和使用场景
qq_41723904的博客
03-15 748
CopyOnWriteArrayList的缺陷和使用场景
关于ArrayList与CopyOnWriteArrayList的遍历remove操作
MrLi_IT的博客
04-11 7821
今天在测试list的遍历删除的时候突然发现，有报错 1、当List中有五个对象的时候，使用CopyOnWriteArrayList实例化 我们会发现当使用foreach方法删除的时候是没有问题的，但是会发现，当使用迭代方法 iterator.remove() 删除的时候就会报错 2、使用ArrayList实例化对象 ...
CopyOnWriteArrayList解析
TuGeLe的博客
11-10 552
CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。 其原理是： 初始化的时候只有一个容器，很长一段时间，这个容器数据、数量等没有发生变化，多个线程都是读取同一个容器中的数据，所以这样大家读到的数据都是唯一、一致、安全的，如果后来有线程往里面增加了一个数据，这个时候Copy
JavaCV推流过程中遇到内存溢出，JVM异常OOM问题的解决方法
banmajio的博客
04-28 3223
JvaCV推流过程中遇到内存溢出，JVM异常OOM问题的解决方法问题分析 项目码云（Gitee）地址：https://gitee.com/banmajio/RTSPtoRTMP 项目github地址：https://github.com/banmajio/RTSPtoRTMP 个人博客：banmajio’s blog javacv使用ffmpeg将rtsp转rtmp直播流播放的问题解决与优化...
CopyOnWriteArrayList----ReadWriteLock---ConcurrentHashMap
zy512638348的博客
10-06 1644
1.CopyOnWirteArrayList   适用于写少读多的并发场景 2.ReadWriteLock  即为读写锁，要求写与写之间互斥，读与写之间互斥，读与读之间可以并发执行，在读多写少的情况下可以提高效率。 3.ConcurrentHashMap是同步的HashMap，读写都加锁 4.volatile只保证多线程操作的可见性，不保证原子性 例题：下列关于Java并发的说法中
高并发容器CopyOnWriteArrayList原理解析
踩踩踩从踩的博客
09-23 1430
CopyOnWriteArrayList 实现arraylist多线程数据安全的方式 jdk提供的Collections.SynchronizedList() 所有方法进行添加synchronized块 public void add(int index, E element) { synchronized (mutex) {list.add(index, element);} } 使用reentrantLock自己对add时，进行对读写操作加锁 List
使用线程处理大数据任务可能会出现什么问题，如何解决
最新发布
12-01
<think> 我们正在讨论使用线程处理大数据任务时可能出现的问题及解决方法。根据引用内容，我们可以总结出以下关键点： 引用[1]提到：多线程处理大数据时可能打乱数据原有顺序，同时需要保证数据添加的安全性和顺序性。解决方法包括使用多线程和锁机制。 引用[2]：大数据处理中，传统方法可能遇到性能瓶颈，并行计算（包括多线程）是提高速度的方法之一。 引用[4]：多线程读取文件时存在独占和定位问题，设计复杂且容易出错。 引用[5]：多线程及高并发处理中，负载均衡可以解决数据流量过大和网络负荷问题。 结合以上引用和线程处理大数据的一般知识，我们整理如下： ### 一、线程处理大数据任务的主要问题 1. **数据竞争与线程安全** - 多线程并发读写共享数据结构（如List、Map）时易引发竞态条件 - 示例：两个线程同时向ArrayList添加数据导致数据覆盖或结构破坏 2. **执行顺序不可控** - 线程调度由操作系统决定，导致： - 数据处理顺序与原始数据顺序不一致（引用[1]） - 输出结果乱序（如日志记录、结果写入） 3. **资源争用瓶颈** - I/O瓶颈：多线程读写同一文件时引发阻塞（引用[4]） - 内存瓶颈：大量线程同时加载数据导致OOM(OutOfMemory) - CPU瓶颈：线程数超过CPU核心数引发频繁上下文切换 4. **死锁风险** - 线程间循环等待锁资源（如线程A持有锁L1等待L2，线程B持有L2等待L1） 5. **调试复杂性** - 非确定性问题（如偶发性数据丢失）难以复现和定位 ### 二、针对性解决方案 #### 1. 保证线程安全 - **锁机制**（引用[1][5]） ```java // Java示例：使用ReentrantLock private Lock lock = new ReentrantLock(); public void safeAdd(List<String> list, String data) { lock.lock(); try { list.add(data); } finally { lock.unlock(); } } ``` - **无锁数据结构** - 使用`ConcurrentHashMap`、`CopyOnWriteArrayList`等线程安全集合 - 示例：`ConcurrentHashMap<String, Integer> counter = new ConcurrentHashMap<>();` #### 2. 维持数据顺序 - **顺序执行队列**（引用[3]） - 将数据按原始顺序分块，每块分配独立处理单元 - 使用阻塞队列（如`BlockingQueue`）按序收集结果（引用[4]） - **顺序标记法** ```python # Python示例：为每个数据项添加序号 from threading import Lock results = [] lock = Lock() def process_data(index, data): result = complex_calculation(data) with lock: results.append((index, result)) # 存储序号和结果 # 完成后按序号排序 sorted_results = sorted(results, key=lambda x: x[0]) ``` #### 3. 资源争用优化 - **I/O优化** - 采用生产者-消费者模式分离读写（引用[4]） ```java // Java示例：使用BlockingQueue解耦 BlockingQueue<Data> queue = new LinkedBlockingQueue<>(1000); // 生产者线程 new Thread(() -> { while(hasMoreData()) { queue.put(readData()); // 从文件读取 } }).start(); // 消费者线程 new Thread(() -> { while(true) { process(queue.take()); // 处理数据 } }).start(); ``` - **内存控制** - 限制线程数：线程池固定大小（如`Executors.newFixedThreadPool(8)`） - 分批加载数据：每次从磁盘读取固定量数据（如分页查询） - **CPU优化** - 根据任务类型设置合理线程数： - I/O密集型：线程数 ≈ CPU核数 * (1 + 平均等待时间/平均计算时间) - CPU密集型：线程数 ≤ CPU核心数 #### 4. 避免死锁 - **锁顺序协议**：所有线程按相同顺序获取锁 - **超时机制**：尝试获取锁时设置超时（如`tryLock(100, TimeUnit.MILLISECONDS)`） - **死锁检测**：定期检查线程等待图（生产环境推荐使用Java Mission Control） #### 5. 简化调试 - **线程局部变量**：使用`ThreadLocal`避免共享状态 - **日志追踪**：为每个任务分配唯一ID并记录全链路日志 - **熔断机制**：监控线程异常率，超过阈值自动终止任务 ### 三、典型架构方案 ```mermaid graph LR A[数据源] --> B[数据分片] B --> C[线程池处理] C --> D{有序聚合?} D -->|是| E[序号标记+排序] D -->|否| F[直接输出] E --> G[结果写入] F --> G G --> H[完成] ``` > **关键原则**： > - 读分离：单线程读 → 多线程处理 → 单线程写（引用[4][5]） > - 状态最小化：避免共享可变状态 > - 资源可控：线程池需设置队列长度和拒绝策略 §§相关问题§§ 1. 如何确定线程池的最佳大小？ 2. 无锁编程如何实现高效并发？ 3. 分布式环境下如何扩展多线程数据处理能力？ 4. 如何监控多线程程序的性能瓶颈？ 5. 大数据处理中线程模型与Actor模型的优劣对比？ </think>### 使用线程处理大数据任务的问题及解决方案 #### 一、核心问题 1. **数据顺序错乱** - 问题：多线程并发处理会打乱数据原始顺序（如处理结果与输入顺序不一致）[^1] - 原因：线程调度不可控，处理完成时间随机 2. **线程安全问题** - 问题：并发读写共享数据结构导致数据损坏（如List/Map并发修改异常） - 风险：脏数据、计算错误、程序崩溃[^1] 3. **资源争用瓶颈** - I/O瓶颈：多线程争抢磁盘/网络资源（如同时读取大文件导致阻塞）[^4] - 内存瓶颈：大数据加载引发OOM(OutOfMemoryError) - CPU瓶颈：线程数超过核心数引发频繁上下文切换 4. **死锁风险** - 问题：线程间循环等待资源（如线程A持有锁L1等待L2，线程B持有L2等待L1） - 后果：程序永久卡死 5. **任务管理复杂** - 问题：线程生命周期管理困难（如异常处理、任务取消） - 示例：部分线程阻塞导致整体任务停滞[^3] --- #### 二、针对性解决方案 1. **保障数据顺序性** - **序号标记法**：为每个数据项添加序号，处理完成后按序号重组 ```java // Java示例：带序号的结果收集 ConcurrentMap<Integer, Result> orderedResults = new ConcurrentHashMap<>(); executor.submit(() -> { Result r = process(data); orderedResults.put(data.getIndex(), r); // 按输入序号存储 }); ``` - **分段锁策略**：将数据分块（如每1万条一个批次），块内顺序处理 2. **解决线程安全问题** - **无锁数据结构**：使用`ConcurrentHashMap`、`CopyOnWriteArrayList` - **细粒度锁**：替代全局锁，降低冲突概率 ```python # Python示例：分段锁 from threading import Lock segment_locks = [Lock() for _ in range(16)] # 16个锁分段 def safe_write(key, value): idx = hash(key) % 16 with segment_locks[idx]: shared_map[key] = value ``` 3. **资源争用优化** - **I/O优化**： - 生产者-消费者模式：单线程读数据 → 线程池处理 → 单线程写结果[^4] - 零拷贝技术：使用`FileChannel.transferTo`减少内存复制 - **内存控制**： - 分批加载：每次处理固定数据量（如分页查询） - 堆外内存：使用`ByteBuffer.allocateDirect`避免GC压力 - **CPU优化**： - 动态线程池：根据负载调整线程数（如Tomcat线程池模型） - 绑定CPU核心：`taskset`命令减少上下文切换 4. **死锁预防** - **锁排序协议**：所有线程按固定顺序获取锁（如按锁ID升序） - **超时机制**：设置锁等待超时（Java中`tryLock(timeout)`） - **死锁检测**：定期扫描线程等待图（如使用`jstack`） 5. **任务管理增强** - **线程池监控**：实现`RejectedExecutionHandler`处理拒绝任务 - **屏障同步**：使用`CyclicBarrier`分阶段处理 - **熔断机制**：异常率超阈值时暂停新任务（类似Hystrix）[^3] --- #### 三、架构级优化方案 ```mermaid graph LR A[数据源] --> B[数据分片] B --> C{处理类型} C -->|有状态任务| D[Key-Based 路由] C -->|无状态任务| E[轮询分配] D --> F[线程池Group1] E --> F[线程池Group2] F --> G[有序结果收集器] G --> H[输出] ``` 1. **分层处理架构** - 接入层：单线程数据分片 - 处理层：线程池并行计算 - 输出层：单线程顺序写入 2. **负载均衡策略** - 动态分配：根据线程负载分配任务（如Linux CFS调度器） - 异构优化：为SSD/HDD存储设备设置不同线程权重[^5] 3. **容错机制** - 检查点：定期保存状态（如Flink Checkpointing） - 重试队列：失败任务进入延迟重试队列[^3] --- > **关键原则**： > - 读分离：单线程读 → 多线程处理 → 单线程写[^4] > - 状态外置：共享数据存入Redis/等外部存储 > - 资源隔离：CPU密集型与I/O密集型线程分离[^5]
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值