Java和同步链表[重复]

Question

我有问题。第一个是为什么当我们运行这个函数时会出现 ConcurrentModificationException ？

public static void testList() {
    List<String> list = new ArrayList<String>();
    list.add("str3");

    for (String st : list) {
        if (st.equalsIgnoreCase("str3")) {
            list.remove("str3");
        }
    }
    System.out.println(list);
}

我的事情，因为增强了使用迭代器（检查modificationsCount），但我要求确定。这就是异常的原因吗？

第二个问题是如果我使用Collections.synchronizedList(new LinkedList<Something>()); 我可以使用 2 个或更多增强的 for 循环吗？例如，我必须线程，有时第一个从集合中删除元素，有时第二个在集合中添加元素。我认为即使我们使用迭代器也应该是线程保存（我认为使用迭代器进行了增强）。
提前致谢。

Answer 1

如果您在迭代列表时从列表中删除元素，您将获得ConcurrentModificationException，就像您在上面的示例中所做的那样。为避免这种情况，您应该使用显式迭代器而不是增强的 for 循环，并在找到必须删除的元素时在迭代器而不是列表上调用 remove()：

for (Iterator<String> i = list.iterator(); i.hasNext(); ) {
    String st = i.next();
    if (st.equalsIgnoreCase("str3")) {
        // Remove the element that the iterator is currently pointing to
        i.remove();
    }
}

仅使用Collections.synchronizedList(...) 包装列表并不能让您可以让多个线程同时遍历列表，其中一个线程正在从列表中删除元素。当你这样做时，你仍然会得到一个ConcurrentModificationException。使用Collections.synchronizedList(...) 包裹列表将使列表中的各个方法同步，但多个方法之间不会同步。

您必须通过正确同步您自己的迭代和删除元素的方法，确保如果一个线程正在从列表中删除元素，则没有其他线程正在迭代列表。

Answer 2

对于第一个问题，是的。如果正在枚举列表，则在修改列表时是常见的例外。

第二个问题，是的。但是您需要为每个 for 循环使用 synchronized 块

Answer 3

迭代器未在 SynchronizedCollection 中同步。我附上了 SynchronizedCollection 代码。

static class SynchronizedCollection<E> implements Collection<E>, Serializable {
        private static final long serialVersionUID = 3053995032091335093L;

        final Collection<E> c;  // Backing Collection
        final Object mutex;     // Object on which to synchronize

        SynchronizedCollection(Collection<E> c) {
            this.c = Objects.requireNonNull(c);
            mutex = this;
        }

        SynchronizedCollection(Collection<E> c, Object mutex) {
            this.c = Objects.requireNonNull(c);
            this.mutex = Objects.requireNonNull(mutex);
        }

        public int size() {
            synchronized (mutex) {return c.size();}
        }
        public boolean isEmpty() {
            synchronized (mutex) {return c.isEmpty();}
        }
        public boolean contains(Object o) {
            synchronized (mutex) {return c.contains(o);}
        }
        public Object[] toArray() {
            synchronized (mutex) {return c.toArray();}
        }
        public <T> T[] toArray(T[] a) {
            synchronized (mutex) {return c.toArray(a);}
        }

        public Iterator<E> iterator() {
            return c.iterator(); // Must be manually synched by user!
        }

        public boolean add(E e) {
            synchronized (mutex) {return c.add(e);}
        }
        public boolean remove(Object o) {
            synchronized (mutex) {return c.remove(o);}
        }

        public boolean containsAll(Collection<?> coll) {
            synchronized (mutex) {return c.containsAll(coll);}
        }
        public boolean addAll(Collection<? extends E> coll) {
            synchronized (mutex) {return c.addAll(coll);}
        }
        public boolean removeAll(Collection<?> coll) {
            synchronized (mutex) {return c.removeAll(coll);}
        }
        public boolean retainAll(Collection<?> coll) {
            synchronized (mutex) {return c.retainAll(coll);}
        }
        public void clear() {
            synchronized (mutex) {c.clear();}
        }
        public String toString() {
            synchronized (mutex) {return c.toString();}
        }
        // Override default methods in Collection
        @Override
        public void forEach(Consumer<? super E> consumer) {
            synchronized (mutex) {c.forEach(consumer);}
        }
        @Override
        public boolean removeIf(Predicate<? super E> filter) {
            synchronized (mutex) {return c.removeIf(filter);}
        }
        @Override
        public Spliterator<E> spliterator() {
            return c.spliterator(); // Must be manually synched by user!
        }
        @Override
        public Stream<E> stream() {
            return c.stream(); // Must be manually synched by user!
        }
        @Override
        public Stream<E> parallelStream() {
            return c.parallelStream(); // Must be manually synched by user!
        }
        private void writeObject(ObjectOutputStream s) throws IOException {
            synchronized (mutex) {s.defaultWriteObject();}
        }
    }

根据文档 Iterator is SynchronizedCollection is not synchronized 。因此，如果迭代一个线程，另一个线程可以添加/删除。所以ConcurrentModificationException就会来。