大多数情况下，如果您需要并发列表，则它位于模型对象内部(因为您不应该使用抽象数据类型(如列表)来表示应用程序模型图中的节点)，或者它是特定服务的一部分，您可以自己同步访问。

class MyClass {
  List<MyType> myConcurrentList = new ArrayList<>();
  void myMethod() {
    synchronzied(myConcurrentList) {
      doSomethingWithList;
    }
  }
}

通常这就足够让你继续下去了。如果你需要迭代，迭代列表的一个副本，而不是列表本身，并且只同步你复制列表的部分，而不是在你迭代它的时候。

另外，当并发处理一个列表时，通常要做的事情不仅仅是添加、删除或复制，这意味着该操作变得足够有意义，以保证它自己的方法，并且该列表成为一个特殊类的成员，仅表示这个具有线程安全行为的特定列表。

即使我同意需要一个并发列表实现和Vector / collections . synchronizelist (list)不做的技巧，你肯定需要像compareAndAdd或compareAndRemove或get(…， ifAbsentDo)，即使您有ConcurrentList实现，开发人员在使用并发列表(和映射)时也经常会因为没有考虑真正的事务而引入错误。

在这些场景中，事务对于与并发ADT(抽象数据类型)交互的预期目的来说太小，总是导致我将列表隐藏在一个特殊的类中，并在方法级别上使用synchronized同步访问这个类对象方法。这是确保交易正确的唯一方法。

我已经看到了太多的错误，不能用其他方法来做——至少如果代码很重要，处理一些像金钱或安全或保证一些服务质量措施(例如至少发送一次且只发送一次消息)。

ConcurrentLinkedQueue

如果您不关心是否具有基于索引的访问，而只想要List的插入顺序保持特性，那么可以考虑java.util.concurrent.ConcurrentLinkedQueue。因为它实现了Iterable，一旦你添加完所有的项，你可以使用增强的for语法循环内容:

Queue<String> globalQueue = new ConcurrentLinkedQueue<String>();

//Multiple threads can safely call globalQueue.add()...

for (String href : globalQueue) {
    //do something with href
}

因为获取位置和从给定位置获取元素的行为自然需要一些锁定(您不能让列表在这两个操作之间发生结构变化)。

并发收集的思想是，每个操作本身都是原子的，可以在没有显式锁定/同步的情况下完成。

因此，从给定的List中获取位置n的元素作为原子操作在期望并发访问的情况下没有太大意义。

在java.util.concurrent中有一个并发列表实现。特别是CopyOnWriteArrayList。

CopyOnWriteArrayList是ArrayList的线程安全变体 所有可变操作(添加、设置等)都由 创建底层数组的新副本。

CopyOnWriteArrayList是同步列表实现列表接口的并发替代，它是java.util.concurrent包的一部分，它是线程安全的集合。

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

CopyOnWriteArrayList是故障安全的，当底层的CopyOnWriteArrayList在迭代期间使用ArrayList的单独副本被修改时，不会抛出ConcurrentModificationException。

这通常代价太大，因为拷贝数组涉及每个更新操作，将创建一个克隆副本。CopyOnWriteArrayList是频繁读操作的最佳选择。

/**
         * Returns a shallow copy of this list.  (The elements themselves
         * are not copied.)
         *
         * @return a clone of this list
         */
        public Object clone() {
            try {
                @SuppressWarnings("unchecked")
                CopyOnWriteArrayList<E> clone =
                    (CopyOnWriteArrayList<E>) super.clone();
                clone.resetLock();
                return clone;
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError();
            }
        }

http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArrayList.html https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/CopyOnWriteArrayList.html https://www.logicbig.com/tutorials/core-java-tutorial/java-collections/concurrent-collection-cheatsheet.html

大多数情况下，如果您需要并发列表，则它位于模型对象内部(因为您不应该使用抽象数据类型(如列表)来表示应用程序模型图中的节点)，或者它是特定服务的一部分，您可以自己同步访问。

class MyClass {
  List<MyType> myConcurrentList = new ArrayList<>();
  void myMethod() {
    synchronzied(myConcurrentList) {
      doSomethingWithList;
    }
  }
}

通常这就足够让你继续下去了。如果你需要迭代，迭代列表的一个副本，而不是列表本身，并且只同步你复制列表的部分，而不是在你迭代它的时候。

另外，当并发处理一个列表时，通常要做的事情不仅仅是添加、删除或复制，这意味着该操作变得足够有意义，以保证它自己的方法，并且该列表成为一个特殊类的成员，仅表示这个具有线程安全行为的特定列表。

即使我同意需要一个并发列表实现和Vector / collections . synchronizelist (list)不做的技巧，你肯定需要像compareAndAdd或compareAndRemove或get(…， ifAbsentDo)，即使您有ConcurrentList实现，开发人员在使用并发列表(和映射)时也经常会因为没有考虑真正的事务而引入错误。

在这些场景中，事务对于与并发ADT(抽象数据类型)交互的预期目的来说太小，总是导致我将列表隐藏在一个特殊的类中，并在方法级别上使用synchronized同步访问这个类对象方法。这是确保交易正确的唯一方法。

我已经看到了太多的错误，不能用其他方法来做——至少如果代码很重要，处理一些像金钱或安全或保证一些服务质量措施(例如至少发送一次且只发送一次消息)。