迭代同步包装器是否安全？答案

【问题标题】：Is it safe to iterate over synchronized wrappers?迭代同步包装器是否安全？
【发布时间】：2016-01-04 07:16:05
【问题描述】：

我决定深入研究一下源代码，发现Collections.synchronizedList(List) 的实现如下：

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
        new SynchronizedRandomAccessList<T>(list) :
        new SynchronizedList<T>(list));
}

SynchronizedList 嵌套类在哪里：

static class SynchronizedList<E>
extends SynchronizedCollection<E>
            implements List<E> {
    private static final long serialVersionUID = -7754090372962971524L;
    final List<E> list;

    SynchronizedList(List<E> list) {
        super(list);
        this.list = list;
    }
    SynchronizedList(List<E> list, Object mutex) {
        super(list, mutex);
        this.list = list;
    }

    public boolean More ...equals(Object o) {
        synchronized(mutex) {return list.equals(o);}
    }

    //ommited

    public void add(int index, E element) {
        synchronized(mutex) {list.add(index, element);}
    }

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

    //rest is ommited
}

可以看出，该类使用private 锁定对象来提供线程安全。但是the documentation 允许我们使用锁定工厂方法返回的对象来迭代它。

用户必须手动同步返回的迭代时列出：

因此，我们使用不同的锁来迭代和修改列表（add、remove 等）。

为什么它被认为是安全的？

【问题讨论】：

那么，我们使用不同的锁来迭代和修改列表是什么让你这么认为？
@SotiriosDelimanolis 我引用的源代码。在嵌套类中，我们使用了从外部无法访问的 synchronized(mutex)。

标签： java multithreading synchronized

【解决方案1】：

Collections#synchronizedList 方法

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
            new SynchronizedRandomAccessList<>(list) :
            new SynchronizedList<>(list));
}

使用您在问题中显示的单个参数构造函数。该构造函数调用将this 设置为mutex 的超级构造函数。所有方法都是synchronized on mutex, this。

文档告诉您在迭代时也要同步实例。该引用与方法主体中的 this 相同。

所有这些操作都是（应该，如果你做得对的话）因此共享同一个锁。

【讨论】：