1

以下代码非常非常快地触发了 ConcurrentModificationException：

import java.util.*;
public class SynchFail {
    static List<Integer> LIST = new ArrayList<Integer>();
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    LIST.add(1);
                }
            }}).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    List<Integer> syncList = Collections.synchronizedList(LIST);
                    synchronized(syncList) {
                        for (Integer thisInt : syncList) {
                        }
                    }
                }
            }}).start();
    }
}

...而以下行为应如此：

import java.util.*;
public class SynchSucceed {
    static List<Integer> LIST = new ArrayList<Integer>();
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized(LIST) {
                        LIST.add(1);
                    }
                }
            }}).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized(LIST) {
                        for (Integer thisInt : LIST) {
                        }
                    }
                }
            }}).start();
    }
}

...我的理解是，同步集合是为了防止ConcurrentModificationExceptions 在这种情况下发生（但显然他们没有）。

鉴于此：我应该在哪里使用这些？

4

2 回答 2

4

在第一个代码片段中，您没有遵循以下文档中的说明synchronizedList：

为了保证串行访问，对后备列表的所有访问都通过返回的列表完成是至关重要的。

在另一个线程中，您通过原始添加到列表中LIST，而不是“返回列表”。LIST只是一个正常的ArrayList调用add它不会获得任何锁或类似的东西，所以add在迭代过程中仍然可以成功调用它。

如果你这样做了：

final static List<Integer> LIST = Collections.synchronizedList(new ArrayList<>());
public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                LIST.add(1);
            }
        }}).start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                synchronized(LIST) {
                    for (Integer thisInt : LIST) {
                    }
                }
            }
        }}).start();
}

然后它不会抛出 CME。当您调用add同步列表时，它会尝试获取LIST. 如果迭代正在进行中，锁将已经被另一个线程持有（因为你在synchronized (LIST) { ... }那里做了），所以它会等到迭代结束。将此与第二个代码片段进行比较，并注意这如何使您免于在调用周围编写额外的synchronized (LIST) {}块。add

于 2021-11-18T18:46:19.550 回答
-1

几件事：

  1. 如果您需要对 ArrayList 进行同步访问，则应使用 Vector 代替。它做同样的事情，但它的方法是同步的。
  2. 在您的情况下，第二个片段有效，因为您在两个线程中同步同一对象 LIST
于 2021-11-18T18:45:50.073 回答