文章目录
一、引入
在并发编程中,线程安全的集合类扮演着重要角色。CopyOnWriteArrayList作为List接口的线程安全实现,采用了一种独特的"写时复制"机制来保证线程安全。
二、实现原理解析
2.1 写时复制机制
CopyOnWriteArrayList的核心思想是在执行写操作时,先复制一个新的数组,在新数组上进行修改,最后将新数组替换旧数组。这种机制保证了读操作不需要加锁,从而大大提升了读操作的性能。
以下是其核心实现原理的示例代码：
public class CopyOnWriteArrayList<E> implements List<E> {
private transient volatile Object[] array;
final Object[] getArray() {
return array;
}
final void setArray(Object[] a) {
array = a;
}
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();
}
}
}
2.2 读写分离策略
CopyOnWriteArrayList在读操作时不需要加锁,因为内部数组array使用volatile修饰,保证了数组引用的可见性。写操作则通过ReentrantLock来保证同步。这种读写分离的策略使其特别适合读多写少的场景。
以下是其读写操作的核心实现：
public class CopyOnWriteArrayList<E> {
// volatile修饰的数组引用,保证可见性
private transient volatile Object[] array;
// 用于写操作的锁
final transient ReentrantLock lock = new ReentrantLock();
// 读操作不需要加锁,直接返回数组元素
public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}
// 写操作需要加锁,并复制数组
public E set(int index, E element) {
final ReentrantLock lock = this.lock;
lock.lock(); // 加锁保护写操作
try {
Object[] elements = getArray();
E oldValue = get(elements, index);
if (oldValue != element) {
// 复制数组并修改指定位置的值
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len);
newElements[index] = element;
setArray(newElements);
}
return oldValue;
} finally {
lock.unlock(); // 确保锁的释放
}
}
// 迭代操作也不需要加锁,因为使用的是数组的快照
public Iterator<E> iterator() {
return new COWIterator<E>(getArray(), 0);
}
// 内部迭代器实现
static final class COWIterator<E> implements Iterator<E> {
private final Object[] snapshot;
private int cursor;
COWIterator(Object[] elements, int initialCursor) {
cursor = initialCursor;
snapshot = elements; // 保存当前数组的快照
}
public boolean hasNext() {
return cursor < snapshot.length;
}
@SuppressWarnings("unchecked")
public E next() {
if (!hasNext())
throw new NoSuchElementException();
return (E) snapshot[cursor++];
}
}
}
这种实现方式使得读操作的性能非常高，因为完全不需要加锁，而写操作虽然会复制数组，但通过加锁机制保证了数据的一致性。
三、性能测试分析
通过一个实际的性能测试来了解CopyOnWriteArrayList在不同场景下的表现：
public class CopyOnWriteArrayListTest {
private static final int THREAD_COUNT = 10;
private static final int OPERATION_COUNT = 1000;
public static void main(String[] args) throws InterruptedException {
// 初始化测试数据
List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
// 测试并发写性能
CountDownLatch writeLatch = new CountDownLatch(THREAD_COUNT);
long writeStartTime = System.nanoTime();
for (int i = 0; i < THREAD_COUNT; i++) {
new Thread(() -> {
for (int j = 0; j < OPERATION_COUNT; j++) {
copyOnWriteList.add("Item " + j);
}
writeLatch.countDown();
}).start();
}
writeLatch.await();
long writeTime = System.nanoTime() - writeStartTime;
System.out.printf("CopyOnWriteArrayList写入耗时: %d ms%n", writeTime / 1_000_000);
// 测试并发读性能
CountDownLatch readLatch = new CountDownLatch(THREAD_COUNT);
long readStartTime = System.nanoTime();
for (int i = 0; i < THREAD_COUNT; i++) {
new Thread(() -> {
for (int j = 0; j < OPERATION_COUNT; j++) {
copyOnWriteList.get(j % copyOnWriteList.size());
}
readLatch.countDown();
}).start();
}
readLatch.await();
long readTime = System.nanoTime() - readStartTime;
System.out.printf("CopyOnWriteArrayList读取耗时: %d ms%n", readTime / 1_000_000);
}
}
四、应用场景分析
4.1 事件监听器管理
CopyOnWriteArrayList非常适合用于管理事件监听器列表,因为监听器的注册和移除操作相对较少,而事件触发时需要频繁遍历通知所有监听器：
public class EventManager {
private final List<EventListener> listeners = new CopyOnWriteArrayList<>();
public void addEventListener(EventListener listener) {
listeners.add(listener);
}
public void removeEventListener(EventListener listener) {
listeners.remove(listener);
}
public void fireEvent(Event event) {
for (EventListener listener : listeners) {
listener.onEvent(event);
}
}
}
4.2 缓存实现
在读多写少的缓存场景中,CopyOnWriteArrayList也能发挥其优势：
public class CacheManager<T> {
private final List<T> cache = new CopyOnWriteArrayList<>();
public void updateCache(List<T> newData) {
cache.clear();
cache.addAll(newData);
}
public List<T> getCache() {
return new ArrayList<>(cache); // 返回副本,避免外部修改
}
public T getCacheItem(int index) {
return cache.get(index);
}
}
五、最佳实践建议
5.1 性能优化技巧
在使用CopyOnWriteArrayList时,我们需要注意一些性能优化的关键点：
public class OptimizedListOperations {
private final List<String> list = new CopyOnWriteArrayList<>();
// 批量添加优化
public void batchAdd(Collection<String> items) {
// 一次性复制,而不是逐个添加
List<String> currentList = new ArrayList<>(list);
currentList.addAll(items);
((CopyOnWriteArrayList<String>)list).setArray(currentList.toArray());
}
// 迭代时的快照语义
public void processItems() {
// 利用快照特性,整个迭代过程使用同一个数组
for (String item : list) {
processItem(item);
}
}
private void processItem(String item) {
// 处理单个元素的业务逻辑
}
}
5.2 常见陷阱规避
在使用CopyOnWriteArrayList时要注意规避一些常见的性能陷阱：
public class ListUsageGuide {
private final CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
// 避免频繁修改操作
public void wrongUsage() {
// 错误示范：频繁修改导致性能问题
for (int i = 0; i < 10000; i++) {
list.add("item" + i); // 每次add都会复制整个数组
}
}
// 正确的使用方式
public void correctUsage() {
// 正确示范：批量操作
ArrayList<String> temp = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
temp.add("item" + i);
}
list.addAll(temp); // 只复制一次数组
}
}
总结
CopyOnWriteArrayList通过其独特的写时复制机制,在保证线程安全的同时,为读多写少的并发场景提供了excellent的解决方案。它的核心优势在于读操作完全不需要加锁,从而能够提供更好的读性能。不过,这种实现机制也带来了写操作的开销,因为每次修改都需要复制整个数组。
在实际应用中,需要权衡使用场景的特点来决定是否使用CopyOnWriteArrayList。对于事件监听器列表、配置信息等读多写少的场景,CopyOnWriteArrayList是一个理想的选择。而对于写操作频繁的场景,可能需要考虑其他的线程安全集合实现。
标签：Java,int,List,50,private,final,CopyOnWriteArrayList,new,public From： https://blog.csdn.net/weixin_55344375/article/details/144029309