在列表上同步 [重复]

Question

假设我有这个代码块：

List<Integer> lst = Collections.synchronizedCollection(new ArrayList<>());

而我有以下两种方法：

public Integer returnFirst() {
  lst.get(0);
}

public void iterate() {
synchronized(lst) {
     Iterator i = lst.iterator();
     while (i.hasNext()) {
       System.out.println(i);
     }
   }
}

假设一个线程调用iterate()，然后另一个线程调用returnFirst()。由于您在迭代中同步 List 对象，并且迭代当前正在运行，因此 returnFirst() 会被阻止吗？

Answer 1

是的。 看看SynchronizedCollection构造函数和SynchronizedList#get方法：

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

        public E get(int index) {
            synchronized (mutex) {return list.get(index);}
        }

可以看到，用于控制并发访问的内部互斥锁其实就是对象本身（mutex = this），也就是说你的iterate()方法中的lst.get(0)和synchronized(LST)竞争同一个锁：对象自己。

另外，你的代码不会编译，请将synchronizedCollection替换为synchronizedList。

简单代码测试：

    public static void main(String[] args) throws InterruptedException {
        List<Integer> list = Collections.synchronizedList(new ArrayList<>());
        list.add(1);
        new Thread(() -> {
            try {
                synchronized(list) {
                    Thread.sleep(5000);
                    Iterator i = list.iterator();
                    while (i.hasNext()) {
                        System.out.println(i.next());
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        Thread.sleep(100);
        new Thread(() -> {
            // It will block for 5 seconds and then output
            System.out.println(list.get(0));
        }).start();
    }

Answer 2

是的，你是对的。 returnFirst 在 iterate 完成之前不会运行。