迭代同步包装器是否安全?
Is it safe to iterate over synchronized wrappers?
我决定深入研究一下源代码,发现 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
嵌套 class 是:
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
}
可以看出,class 使用 private
锁对象来提供线程安全。但是 the documentation 允许我们通过锁定工厂方法返回的对象来迭代它。
It is imperative that the user manually synchronize on the returned
list when iterating over it:
因此,我们使用不同的锁来迭代和修改列表(add
、remove
等)。
为什么认为它是安全的?
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
相同。
所有这些操作(应该,如果你做对了)因此共享同一个锁。
我决定深入研究一下源代码,发现 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
嵌套 class 是:
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
}
可以看出,class 使用 private
锁对象来提供线程安全。但是 the documentation 允许我们通过锁定工厂方法返回的对象来迭代它。
It is imperative that the user manually synchronize on the returned list when iterating over it:
因此,我们使用不同的锁来迭代和修改列表(add
、remove
等)。
为什么认为它是安全的?
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
相同。
所有这些操作(应该,如果你做对了)因此共享同一个锁。