CopyOnWriteArraylist同步方法
CopyOnWriteArrayList是Java中的一个线程安全的List实现类。它通过在修改操作时创建一个新的副本来实现线程安全，因此可以在并发环境下进行高效的读操作。
CopyOnWriteArrayList的主要特点包括：
- 线程安全：CopyOnWriteArrayList通过使用写时复制的机制来保证线程安全性，即在修改操作时创建一个新的副本，读操作不会阻塞，可以并发进行。
- 高效的读操作：由于读操作不需要加锁，因此可以实现高效的并发读取，适用于读多写少的场景。
- 适用于数据不频繁变动的场景：由于每次修改操作都会创建一个新的副本，因此适用于数据变动不频繁的场景，如果修改操作频繁，会导致大量的内存复制，性能较低。
CopyOnWriteArrayList的应用场景包括：
- 缓存：由于CopyOnWriteArrayList适用于读多写少的场景，可以用于实现缓存，提高读取性能。
- 事件监听器列表：当需要在多个线程中添加、删除和遍历事件监听器列表时，CopyOnWriteArrayList可以保证线程安全性。
- 只读数据：当数据是只读的，不需要修改时，可以使用CopyOnWriteArrayList来提供线程安全的读取操作。
腾讯云提供的相关产品和产品介绍链接地址如下：
- 云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：https://cloud.tencent.com/product/cdb_mysql
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 人工智能（AI）：https://cloud.tencent.com/product/ai
- 物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 移动开发（移动推送）：https://cloud.tencent.com/product/umeng
- 区块链（BCS）：https://cloud.tencent.com/product/bcs
- 元宇宙（Tencent XR）：https://cloud.tencent.com/product/xr
需要注意的是，以上链接仅供参考，具体的产品选择应根据实际需求和情况进行评估和选择。
相关·内容
全,
边缘向量类在ArrayList上的优点是它是同步的，因此确保线程安全。然而，在CopyOnWriteArrayList和Vector之间，应该考虑线程安全和性能方面的优先考虑。
浏览 5提问于2010-10-12得票数 10
回答已采纳
3回答
在Java语言中：List.iterator()是线程安全的吗?也就是说，返回的迭代器是反映列表在任何时候的当前状态，还是仅仅反映列表在创建时的状态？
浏览 0提问于2011-05-01得票数 24
回答已采纳
在不使用Collections.synchronizedList()的情况下，使数组列表同步的其他方法是什么？
浏览 5提问于2015-07-29得票数 1
回答已采纳
根据我的理解，并发集合类优先于同步集合，因为并发集合类不会锁定整个集合对象。相反，它们会锁定集合对象的一小部分。
但是当我检查CopyOnWriteArrayList的add方法时，我们正在获取一个完整集合对象的锁。那么为什么CopyOnWriteArrayList比Collections.synchronizedList返回的列表更好呢？我在CopyOnWriteArrayList的add方法中看到的唯一区别是，每次调用add方法时，我们都会创建该数组的副本。
public boolean add(E e) {
final ReentrantLock lock = this.lock
浏览 1提问于2015-03-11得票数 26
回答已采纳
2回答
地图内采集的同步
、、、
下面是演示这种情况的示例代码：
public class ConnectionRegistry {
private ConcurrentMap<String, List<Connection>> registry = new ConcurrentHashMap<>();
public List<Connection> find(String key) {
List<Connection> connections = registry.get(key);
if (null == con
浏览 1提问于2017-05-13得票数 2
回答已采纳
我需要将一些对象存储到数据库中。
首先，
我将它们存储在内存中(存储在一个集合中)
当其中一个正确地存储在数据库中时，我将其删除。
所以,
public class AuditService {
private CopyOnWriteArrayList<Audit> copyWrite;
public void flush(Audit... audits) {
Collection<Audit> auditCollection = Arrays.asList(audits);
this.copyWrite
浏览 1提问于2018-12-11得票数 1
因此，我目前正在一个支持multie客户端的服务器上工作，我有一个线程来检查是否有任何套接字连接到给定的端口，然后将它们添加到一个数组列表中，其他线程用来更新我需要对客户机所做的一切(更新信息，检查DataInputStream，通过服务器发送文本)等等。
客户代码：
public class Loop implements Runnable{
ArrayList<ClientInstance> clientsConnected = new ArrayList<ClientInstance>();
@Override
public void run() {
浏览 5提问于2015-06-04得票数 3
回答已采纳
以下代码没有在完成并行处理后将所有元素放入目标列表中。这有什么原因吗？
public static void main(String[] args) {
List<Integer> source =new ArrayList<>();
List<Integer> destination = new ArrayList<>();
IntStream.range(0, 10000).forEach(element ->{
source.add(element);
});
//Syste
浏览 194提问于2020-02-06得票数 10
2回答
同步采集吸气器
、、
IIUC，一个只被synchronized方法访问的synchronized应该是线程安全的，对吗？
例如，
class Foo {
private List<String> mList = new LinkedList<>();
public synchronized List<String> getList() {
return mList;
}
}
假设这个getter专门用于访问列表--所有操作都是通过getList()进行的--我觉得它应该是线程安全的--但是我很高兴被告知我错了。
TYIA
浏览 0提问于2017-04-17得票数 0
回答已采纳
1回答
我试图得到一个列表，它的大小，但当这样做时，我得到了一个关于size()方法的ConcurrentModificationException。这很奇怪，因为我没有试图在迭代列表的同时修改它。这是我的一些代码，可能会导致它，但我看不出它的问题。
主要方法：
private void setupCharacterGrid() {
currentCharacters.add(0, new Character("add", "add"));
if (currentCharacters.size() < 9) {
sub(0, cu
浏览 2提问于2014-01-24得票数 2
我用这段代码得到的ConcurrentModificationException是什么？我有一个同步(侦听器)锁。
private void notifyListeners(MediumRendition rendition) {
if (rendition == null) return;
synchronized (listeners) {
for (RenditionEventListener l : listeners) {
if (l.renditionType.equals(rendition.getType()) &
浏览 0提问于2012-01-31得票数 0
回答已采纳
2回答
这是我的家庭作业问题之一：
在多线程程序上使用链接列表有什么问题？
我的答覆如下，如有任何其他意见，我谨此陈辞：
问题在于缺乏并发性--为了使用链接列表，我们必须对其使用锁，这样对它所持有的内部对象所做的更改将是可重放的(因为每个对象都保存对下一个对象的引用)，一旦锁定了链接列表，我们基本上就是“关闭”了使用多个线程的选项，因为我们可以分别锁定每个项。
我完全不确定我的答案，有什么建议吗.
浏览 1提问于2013-04-05得票数 1
6回答
我在Java应用程序中运行了多个线程，它们都需要访问相同的列表。然而，只有一个线程实际上需要插入/删除/更改列表，而其他线程只需要访问它。
在其他线程中，我想要制作列表的副本，以便在需要阅读的时候使用，但是有任何方法可以以线程安全的方式完成吗？如果我有一种方法来逐个复制列表元素，并且列表发生了变化，那就会把它搞砸了，不是吗？
编辑：
这个列表不会经常被删除，所以如果我只是正常地复制它并捕获异常，它会起作用吗？如果列表在拷贝的中间增加，而我错过了它，那么它对功能并没有什么影响。
浏览 3提问于2017-06-23得票数 1
回答已采纳
7回答
我有一个预先填充的数组列表。并且我有多个线程可以从数组列表中删除元素。每个线程调用下面的remove方法，并从列表中删除一项。下面的代码给了我一致的行为吗？
ArrayList<String> list = Collections.synchronizedList(new ArrayList<String>());
void remove(String item)
{
do something; (doesn't work on the list)
list.remove(item);
}
谢谢!
浏览 3提问于2012-07-06得票数 65
回答已采纳
具有通过类型保存与关键字相同的事件的事件监听器列表的映射，
func_1()将开始从映射中获取一种类型的listenerlist，并迭代该列表以处理每个侦听器的事件。
当一个监听器完成处理后，它会要求将其从map中的listenerlist中删除。
因为侦听器在迭代器中，所以将其从原始列表中删除将导致获取下一个侦听器的iterator.previous()中出现java.util.ConcurrentModificationException。
问题是，如果使用CopyOnWriteArrayList复制侦听器列表，然后在其上使用迭代器，因为它是列表的副本，当侦听器从其他线程中删除时，它仍然会
浏览 9提问于2017-01-18得票数 1
我正在使用Map将客户的篮子项目存储在内存中。我的地图有以下签名Map<Integer, Basket> customerBaskets = new ConcurrentHashMap<>();
每个Basket类都有一个定义为Collection<Item> items = new ArrayList<>()的项列表。
在应用程序启动期间，所有加载到地图中的客户和一个空篮子分配给他们。现在，我想以线程安全的方式将项目添加到客户的篮子中。由于ConcurrentHashMap读取没有锁定，所以我可以基于customerId获得篮子，并自由地将项添
浏览 11提问于2022-04-20得票数 0
1回答
我试图做一个简单的小组聊天，在那里有一个服务器和几个客户端。目标是当客户端向服务器发送消息时，服务器只将该消息发送回所有其他客户端。我让服务器向所有客户发送消息，但他没有发送客户消息。
服务器代码：
package Group;
import java.net.*;
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.*;
public class GroupServer extends Threa
浏览 0提问于2018-06-30得票数 0
回答已采纳
我有一个场景，我想在方法中使用StringBuilder作为局部变量。我知道如果StringBuilder是一个局部方法变量，它应该不会有任何关于线程安全的问题。
但是，如果我将一个实例变量附加到StringBuilder，如下所示：
class MyClass {
private List<String> property;
public void myMethod() {
StringBuilder sb = new StringBuilder();
for(String s : property) {
浏览 0提问于2013-06-04得票数 3
CopyOnWritearraylist和Collections.synchronizedList(..)有什么区别？什么时候应该优先考虑其中一个。
浏览 0提问于2010-10-02得票数 14
回答已采纳
我只调用了addAll并清除了列表，但是需要它来实现线程安全，有没有这样的列表呢？谢谢
浏览 3提问于2014-10-09得票数 1
2回答
我有一个非粘性服务，它通过一个广播接收器定期被调用，以启动一个线程来执行一些任务。当线程正在运行时，一个正在进行的通知会显示一些进度信息，以及一个用于打开状态页面的按钮。
此状态页显示当前正在处理的项的列表，此列表是线程和此活动都使用的静态ArrayList。当状态活动启动时，我有一个null检查：
if(Global.statusItems == null)
{
Global.statusItems = new ArrayList<StatusPageItem>();
}
线程仍在运行，并且可以很好地访问ArrayList，但是一旦启动了状态活动，它就会重新创建Array
浏览 2提问于2012-08-29得票数 2
回答已采纳
6回答
在多线程Java应用程序中，我需要遍历一个对象集合。因为当我迭代集合和对象时，它们都可以被另一个线程修改，所以我需要使用同步。
但是，不建议使用嵌套的同步块，因为它们可能会导致死锁。我该如何解决这个问题？
Collection<Data> dataCollection = something.getDataCollection();
synchronized ( dataCollection ) {
for ( final Data data : dataCollection ) {
synchronized ( data ) {
data.doSomet
浏览 4提问于2011-02-27得票数 6
回答已采纳
6回答
我有存储许多对象的ArrayLists，并且经常从ArrayLists中添加和删除对象。一个线程对数据结构进行操作，每20ms左右更新一次ArrayList的对象。另一个线程遍历ArrayLists并使用它们的元素来绘制对象(也是每隔20-30ms)。
如果使用for循环遍历ArrayLists，则IndexOutOfBoundsExceptions比比皆是。如果使用迭代器遍历ArrayLists，则ConcurrentModificationExceptions比比皆是。同步ArrayLists，如下所示：
List list = Collections.synchronizedList
浏览 1提问于2011-04-12得票数 5
回答已采纳
2回答
我不确定我是否理解Java中的同步列表。假设我有以下内容：
List<Integer> numbers = Collections.synchronizedList(new ArrayList<Integer>());
// Assumption: This is running on a separate thread
public void add() {
numbers.add(new Random().nextInt(100));
}
// This is also running on a separate thread
publi
浏览 0提问于2013-05-28得票数 3
回答已采纳
1回答
我想转换以下代码，以适应多线程环境。
List<Observer> list = new ArrayList<>();
public void removeObserver(Observer p) {
for (Observer observer: list) {
if (observer.equals(p)) {
list.remove(observer);
break;
}
}
}
public void addObserver(Observer p) {
浏览 1提问于2020-05-20得票数 0
当我清除数组时，我会得到一个ConcurrentModificationException。
package net.minecraft.client.gui;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.block.Xray;
import net.m
浏览 7提问于2014-07-08得票数 2
4回答
返回Java数组与集合
、、、、
我正在尝试考虑java应用程序中关于内存分配和多线程的一些设计，这是我想知道的：
我有一个类，它有一个同步的集合，比如说一个列表，它每秒更新几次，但是所有的更新都发生在这个类及其自己的线程中，而不是来自其他线程。但是，我还有许多其他线程调用getCollection()方法并执行foreach，以只读方式迭代其内容。这是我不知道的：
如果另一个线程正在迭代同步的集合，那么执行更新的单个线程是否必须等待到没有其他线程在迭代的时间点？
我的第二个问题是，通过执行.toArray来返回集合的数组副本，而不是集合本身，似乎是有意义的，但从内存的角度来看，这不需要每次都分配一个新的数组，这个数组的大小就
浏览 0提问于2011-03-24得票数 3
回答已采纳
如果我使用CopyOnWriteArrayList在线程之间共享项目列表，那么如果这些项被不同的线程更新和读取，是否还需要同步它们呢？
目前，我的项目类定义如下。是否需要将同步添加到每个getter和setter中？
基本上，我希望确保一个线程的更改在另一个线程中是可见的-我认为CopyOnWriteArrayList将提供一个内存屏障来确保这一点，但我想确定-谢谢。
public class MyClass {
private String string;
private Long longObj;
private long longprim;
public
浏览 3提问于2014-04-09得票数 0
回答已采纳
我在GUI (渐变、纹理、文本等)的“对象”上画了一组“效果”。基础系统的性质意味着这个效果集合可以被多个线程访问。大多数操作都是读取操作，所以目前我使用的是一个工作正常的CopyOnWriteArrayList。
但现在，每当我添加新效果或更改效果的绘制顺序时，我都需要根据它们的绘制顺序对效果集合进行排序。我还需要能够在正向和反向( iterater.next() & iterator.previous() )中遍历集合。
经过一些研究，我发现CopyOnWriteArrayLists不喜欢被分类：
如果您尝试对一个CopyOnWriteArrayList排序，您将看到列表抛出一
浏览 3提问于2014-03-06得票数 1
回答已采纳
我正在使用Spring ThreadPoolTaskScheduler，我需要通过一些条件来查找和取消未来。
在Runnable任务中有一个ScheduledFuture字段并将任务收集到ArrayList中是正确的吗？我应该使用CopyOnWriteArrayList吗？
class Task implements Runnable {
public Task(int id) {
this.id = id;
}
private final int id;
private ScheduledFuture future;
public void setFuture(S
浏览 0提问于2018-10-17得票数 1
基本上，我有很多对象的数据结构，这个结构将被多个线程访问，并且需要对此进行解释。
大量的迭代和对象操作将需要不断地执行(每一个主循环迭代都会导致数据结构中的每个对象在最坏的情况下被修改，而在最好的/正常的情况下则不会被修改)。
目前，我正在使用CopyOnWriteArrayList作为我的结构。此外，在每次迭代中，我都要确保不添加重复项，以尽量减小列表的大小。
使用锁/同步并不理想，因为我希望避免为这些操作搁置线程。
据我所知，我对此的选择如下：
对要添加的每个元素运行contains()检查
从列表中创建一个HashSet并将其转换回来(实质上删除所有重复项)
对数据结构使用C
浏览 0提问于2014-11-21得票数 3
回答已采纳
4回答
Java同步
、、
嗨，我做了一个扩展线程的东西，它添加了一个有IP的对象。然后，我创建了这个线程的两个实例并启动了它们。他们使用相同的列表。
现在我想使用同步来停止并发更新问题。但它不起作用，我想不出原因。
我的主修班：
import java.util.*;
import java.io.*;
import java.net.*;
class ListTest2 {
public static LinkedList<Peer> myList = new LinkedList<Peer>();
public static void main(String [] ar
浏览 6提问于2013-09-15得票数 0
回答已采纳
当我只是迭代一个ArrayList并在循环中为我的应用程序逻辑使用indexOf()时，我得到了indexOf。有人能解释一下背后的原因吗？根据我所读到的，如果在我还在迭代的时候尝试将一个项目添加/删除到/从列表中删除，那么这种情况就会发生。我是不是漏了什么东西？
for (SomeClass c : listOfSomeClass)) {
listOfSomeClass.indexOf(c);
}
浏览 1提问于2020-09-08得票数 0
回答已采纳
2回答
我需要一些帮助处理Android中的三个线程
一个线程是主线程，另一个是GLThread，另一个是我为更新游戏状态而创建的WorkerThread。
我的问题是，它们都需要访问游戏对象的相同LinkedList。GLThread和我的WorkerThread都只从LinkedList中读取，所以没有问题，但有时我会让主线程将另一个游戏对象添加到列表中。
我该如何管理它呢？我尝试在涉及到的函数前面使用同步，但它确实减慢了应用程序的运行速度。
出于某些原因，只是捕获错误而不渲染或更新该帧的游戏状态，会导致它开始永久滞后。
有人有什么好点子吗？
浏览 0提问于2010-03-14得票数 3
回答已采纳
我正在学习类。
复制新数组的目的是什么？其他线程是否可以读取该数组？
因此，如果系统具有高并发性，并且大多数线程的操作都是读操作而不是写操作，那么最好使用CopyOnWriteArrayList。
浏览 50提问于2013-07-25得票数 80
回答已采纳
在JAVA中，当两个并发线程试图从同一个CopyOnWriteArrayList中删除一些元素时会发生什么？会不会有一种未定义的行为？例如，如果列表中有1-10个整数，而1个线程删除前5个整数，2个线程删除前3个整数，则准确的结果将是删除前5个整数的列表。这个能正常工作吗？
浏览 8提问于2016-05-16得票数 1
回答已采纳
考虑一下concurrentGroupBy的签名
static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)
在这里，请考虑下面的图表，说明并行线程如何将数据填充到对应于相应键的相应列表中。
既然在给定的时间点上--可以有可能填充给定列表concurrent?的多线程--为什么在内部不使用一些并发实现的 API文档说明它没有为线程安全的实现提供任何
浏览 3提问于2022-05-13得票数 0
2回答
下面是困扰我的程序，我请求为并发问题提供一个标准的补救方法。
创建一个列表对象(lst)
启动多个线程(更新线程)
将第一条发送到每个更新线程以更新(添加)它。
等待某个定义的时间(t1)让更新线程继续进行更新。
在t1时间过期后，将lst返回到我们无法控制的另一个应用程序(Consumer)。
当返回它时，更新线程可能仍然在更新lst。
消费者应用程序不知道更新线程在后台是否仍在更新列表。
使用者应用程序在lst上做列表操作(添加/删除)。
问题:这将导致并发问题。
如何处理这件事？
如何有效地停止t1后的线程更新？或者有什么标准的方法来处理这件事？s
浏览 2提问于2015-03-31得票数 1
我有一段代码如下
protected List<AMQMessage> waitForReceivedRawMessageFromActiveMq(AMQConsumerMessageListener listener) {
CompletableFuture<List<AMQMessage>> completableFuture = CompletableFuture.supplyAsync(() -> {
while (listener.getMessageList().isEmpty()) {}
return listener.g
浏览 11提问于2020-11-18得票数 0
回答已采纳
1回答
我有多个线程不断地迭代一个叫做“ArrayList”的客户端。
当它们断开连接时，我想从列表中删除单个客户端，但我知道这可能会导致并发修改异常。
我应该用Synchronized块将ArrayList的所有用法括起来吗?这不是一个好主意吗？
另外，ArrayList是否可以被多线程读取而没有问题？
谢谢,
(客户端列表由向所有客户端发送数据的UDP线程不断迭代)
浏览 35提问于2016-12-18得票数 0
回答已采纳
我有一个创建10个线程的对象。该对象有一个用户集合。这些线程中的每一个都可以检查特定用户是否存在，或者可以在集合中添加/删除用户。 我想知道我应该如何实现这种交流。 我应该通过构造函数或线程内部的方法将用户集合传递到每个线程吗？ 我是否应该将主对象传递给每个线程，以便它们可以访问对象的属性？或者在main对象中有特定的方法来处理线程将调用的user集合？ 我不确定在这种情况下的最佳实践是什么。
浏览 9提问于2019-06-08得票数 0
回答已采纳
1回答
我有一个扩展JPanel的类，它通过覆盖paint方法在屏幕上绘制大约10个图像(使用这个方法是因为我希望能够在绘制每个图像时操作它们)。我想要做的是在类中有一个update方法，我每一帧都会传递一个潜在的图像更新列表。这是我所拥有的
List<BufferedImage> imageList = Collections.synchronizedList(new ArrayList());
public void update(list<String> imagePaths) {
for (String path : imagePaths) {
浏览 0提问于2015-01-09得票数 1
我对同步很陌生。我知道，当我尝试使用多线程时，我可能会遇到一些问题，将内容添加到列表中。例如，使用以下代码：
import java.util.ArrayList;
class MySafeList extends ArrayList<Double>{
static ArrayList<Double> mySafeList;
public boolean add(Double d){
mySafeList.add(d);
return true;
}
public int size(){
浏览 1提问于2019-04-24得票数 2
我有一个列表，说有登录名，基于列表内容，我正在处理其他方法，如：
while ( it.hasNext() )
{
method1();
}
而不是等待顺序，因为这些任务是独立的，我想并行运行它们。
我做了以下工作：
ExecutorService service = Executors.newFixedThreadPool(5);
final List<Future<?>> futures = new ArrayList<>();
while ( it.hasNext() )
{
Future<?> fut
浏览 1提问于2019-09-28得票数 1
根据我对CopyOnWriteArrayList中数据更新的理解。使用ReentrantLock锁定set方法，将数据复制到局部变量中，将要添加的数据添加到该局部变量中，然后将其作为整体列表数据进行更新。在向量和synchronizedList的集合方法的同步版本上这样做有什么好处吗？
浏览 4提问于2017-07-19得票数 1
回答已采纳
3回答
易失性数组列表未按预期运行
、、、、
我正在写一个多线程平台游戏。一个线程做绘画工作，另一个线程运行游戏逻辑。我有一个两个线程需要同时访问的数组列表。我在我的paint线程中迭代了array-list的所有元素，在另一个线程中，我有时会删除或添加元素到array-list中。我得到了一个并发修改异常，但我不明白为什么，因为volatile关键字不是一次只允许一个线程访问变量吗？
下面是我的问题的一个例子
我的数组列表
private volatile ArrayList<Entity> entities = new ArrayList<Entity>();
我的绘图代码
for(Entity ent
浏览 0提问于2013-03-31得票数 1
回答已采纳
我有一个多线程程序，多个线程正在访问和编辑我的数据结构；我的数据结构是CopyOnWriteArrayList。由于CopyOnWriteArrayList是Java并发包的一部分，在对其执行修改操作时，是否仍必须将数据结构包装在同步块中？
浏览 4提问于2016-01-07得票数 1
回答已采纳
我没有看到使用Collections.synchronizedList/synchronizedMap的任何实际价值，而且根据文档，我们需要在迭代期间同步list/map，这对性能不好。
我只能使用ConcurrentMap/CopyOnWriteArrayList类。基本上，我是问在什么情况下，我们只需要使用Collections.synchronizedList/synchronizedMap，而不是利用java.util.concurrent包中的类。
浏览 0提问于2013-07-21得票数 2
回答已采纳
如果我的需求要求我对列表的大部分访问都是为了读取和修改(如果有的话)是最小的，为什么我不能只做以下任何一个
同步modifyList方法并使用ArrayList。所有从arraylist读取的数据都是不同步的，或者是 it，do a Collections.synchronizedList(arrayList)或Collections.synchronizedList(不确定它在这里买了什么)
我为什么要用这两种？哪个更好？
浏览 3提问于2011-01-17得票数 0
回答已采纳
我有一个负责从MySQL数据库中清除旧数据的线程。我们批量删除数据库，以便在有大的清除时不会消耗数据库，所以线程执行清除，等待几秒钟，然后再次调用自己以继续清除(如果有任何剩余的记录)。
我的问题是，我们允许人们为需要清除的内容设置多个规则。在一个没有批处理的旧系统中，我们简单地迭代每个“清除规则”并运行查询。
但是，现在我们有了一个系统，在这个系统中线程再次调度自己，由于一个ConcurrentModificationException，我可以再从ArrayList中删除规则
我有一个可以迭代的ArrayList<QueryParameters>。如果没有要清除的记录，我们应该从
浏览 0提问于2013-03-29得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
