并发数组列表

Question

我需要一个类似 ArrayList 的结构，只允许以下操作

• get(int index)
• add(E element)
• set(int index, E element)
• iterator()

由于很多地方都使用了迭代器，所以使用Collections#synchronizedList 太容易出错了。该列表可以增长到几千个元素并且被大量使用，所以我很确定CopyOnWriteArrayList 会太慢。我将从它开始以避免过早的优化，但我敢打赌它不会很好地工作。

大多数访问将是单线程读取。所以我在问什么是正确的数据结构。

---

我虽然将synchronizedList 包装在提供同步迭代器的东西中会做，但它不会因为ConcurrentModificationException。关于并发行为，我显然需要后续读取和迭代器可以看到所有更改。

迭代器不必显示一致的快照，它可能会或可能不会通过set(int index, E element) 看到更新，因为此操作仅用于将项目替换为其更新版本（包含一些附加信息，这是无关紧要的对于迭代器的用户）。这些项目是完全不可变的。

---

我清楚地说明了为什么CopyOnWriteArrayList 不会这样做。 ConcurrentLinkedQueue 毫无疑问，因为它缺少索引访问。我只需要几个操作而不是完全成熟的ArrayList。因此，除非任何与 java 并发列表相关的问题与this question 重复，否则这个问题不是。

Answer 1

在您的情况下，您可以使用ReadWriteLock 访问支持的列表，这允许多个线程读取您的列表。只有当一个线程需要写访问权限时，所有读线程必须等待操作完成。 JavaDoc 清楚地说明了这一点：

ReadWriteLock 维护一对关联的锁，一个用于 只读操作和一个用于写入的操作。读锁可能被持有 同时由多个阅读器线程，只要没有 作家。写锁是独占的。

这是一个示例：

public class ConcurrentArrayList<T> {

    /** use this to lock for write operations like add/remove */
    private final Lock readLock;
    /** use this to lock for read operations like get/iterator/contains.. */
    private final Lock writeLock;
    /** the underlying list*/
    private final List<T> list = new ArrayList();

    {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        readLock = rwLock.readLock();
        writeLock = rwLock.writeLock();
    }

    public void add(T e){
        writeLock.lock();
        try{
            list.add(e);
        }finally{
            writeLock.unlock();
        }
    }

    public void get(int index){
        readLock.lock();
        try{
            list.get(index);
        }finally{
            readLock.unlock();
        }
    }

    public Iterator<T> iterator(){
        readLock.lock();
        try {
            return new ArrayList<T>( list ).iterator();
                   //^ we iterate over an snapshot of our list 
        } finally{
            readLock.unlock();
        }
    }