当前位置：首页 > news >正文

Collections.synchronizedList是如何将List变为线程安全的

news 2025/8/20 18:28:17

一、`synchronizedList` 的线程安全实现逻辑

包装类选择
调用 Collections.synchronizedList(List<T> list) 时，会根据传入 List 是否实现 RandomAccess 接口（如 ArrayList 实现该接口，LinkedList 不实现），返回不同的包装类：

实现 RandomAccess：返回 SynchronizedRandomAccessList（继承自 SynchronizedList）；
未实现：返回 SynchronizedList。

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

核心锁机制
线程安全的核心是 对象锁（mutex）+ synchronized 同步块：

SynchronizedList 继承自 SynchronizedCollection，在父类中初始化 mutex 锁对象（mutex = this，即包装类实例本身）；
对 get、set、add、remove 等所有修改/查询方法，均通过 synchronized (mutex) 包裹，确保同一时刻只有一个线程能执行这些方法。

static class SynchronizedCollection<E> implements Collection<E>, Serializable {private static final long serialVersionUID = 3053995032091335093L;final Collection<E> c;  // Backing Collectionfinal Object mutex;     // Object on which to synchronizeSynchronizedCollection(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@Overridepublic void forEach(Consumer<? super E> consumer) {synchronized (mutex) {c.forEach(consumer);}}@Overridepublic boolean removeIf(Predicate<? super E> filter) {synchronized (mutex) {return c.removeIf(filter);}}@Overridepublic Spliterator<E> spliterator() {return c.spliterator(); // Must be manually synched by user!}@Overridepublic Stream<E> stream() {return c.stream(); // Must be manually synched by user!}@Overridepublic Stream<E> parallelStream() {return c.parallelStream(); // Must be manually synched by user!}private void writeObject(ObjectOutputStream s) throws IOException {synchronized (mutex) {s.defaultWriteObject();}}}

二、效率低下的原因

SynchronizedList 采用 “粗粒度锁” 实现：
所有方法共用同一把 mutex 锁，无论操作是读（如 get）还是写（如 add），都会独占锁。这意味着即使多个线程仅执行读操作，也需要排队等待锁释放，无法实现“读-读并发”，导致并发效率显著低于 CopyOnWriteArrayList 等细粒度锁/无锁实现。

三、遍历需额外加锁的原因

SynchronizedList 内部的锁仅保证 单个方法调用的原子性，但无法保证 多步操作（如遍历）的原子性：

其 iterator() 方法直接返回底层 List 的迭代器（未加锁），迭代器本身不具备线程安全性；
若不加外部锁，可能出现“并发修改异常”（如线程 A 遍历 hasNext() 时存在元素，线程 B 立即删除该元素，线程 A 调用 next() 时会报错）。

因此，官方要求遍历 SynchronizedList 时，需在外部用 synchronized (list) 包裹迭代逻辑，确保遍历全程独占锁，避免并发修改问题。

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

示例代码如下：

List list = Collections.synchronizedList(new ArrayList());
// 正确遍历方式
synchronized (list) {Iterator i = list.iterator(); while (i.hasNext()) {foo(i.next());}
}