面试复盘：Collections.synchronizedList的实现与同步策略分析

在最近一次面试中，我提到了 Collections.synchronizedList 作为线程安全的替代方案，结果面试官追问："你刚刚提到了 Collections.synchronizedList 这个方法，这种直接在外层同步的策略，内部的实现逻辑是什么样的呢？你能讲讲有多少种同步方式么？它们为什么粒度粗呢？" 这让我意识到，仅仅知道用法是不够的，还得深入理解其实现原理和设计考量。下面是我的复盘和分析。

1. Collections.synchronizedList 的基本概念

Collections.synchronizedList 是 Java java.util.Collections 提供的一个工具方法，用于将一个普通的 List（如 ArrayList）包装成线程安全的版本。它通过在外层添加同步机制来保证多线程环境下的安全性，类似于早期的 Vector。

用法示例：

java 复制代码

List<String> list = new ArrayList<>();
List<String> syncList = Collections.synchronizedList(list);

2. 内部实现逻辑

Collections.synchronizedList 的实现并不复杂，它返回一个 SynchronizedList 对象（Collections 内部的静态类）。这个类的核心逻辑是：通过 synchronized 关键字对底层 List 的所有操作进行同步。

2.1 核心字段

final List<E> list：被包装的原始 List 对象。
final Object mutex：同步锁对象，默认是 SynchronizedList 实例本身（this），但如果是 SynchronizedCollection 的子类，可以传入自定义锁。

2.2 方法实现

SynchronizedList 重写了 List 接口的大部分方法，并在每个方法上加了 synchronized 同步块。以几个典型方法为例：

get 方法：

java 复制代码

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

add 方法：

java 复制代码

public boolean add(E e) {
    synchronized (mutex) {
        return list.add(e);
    }
}

remove 方法：

java 复制代码

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

2.3 迭代器的特殊处理

需要注意的是，iterator() 和 listIterator() 返回的迭代器本身并不是线程安全的。因为迭代器操作的是底层 List，而 SynchronizedList 只在方法调用时加锁，迭代过程中无法保证同步。如果需要线程安全的迭代，需要手动加锁：

java 复制代码

List<String> syncList = Collections.synchronizedList(new ArrayList<>());
synchronized (syncList) {
    Iterator<String> it = syncList.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
}

2.4 小结

实现原理 ：通过代理模式，将所有对底层 List 的操作包装在 synchronized (mutex) 块中。
锁对象 ：默认是 SynchronizedList 实例本身，保证同一时刻只有一个线程操作。

3. Java 中的同步方式有哪些？

面试官还问到了"有多少种同步方式"，这让我联想到 Java 提供的线程安全 List 实现。以下是常见的几种同步策略：

3.1 Vector（全方法同步）

实现：Vector 是 Java 1.0 引入的线程安全 List，所有方法都用 synchronized 修饰。
特点：与 SynchronizedList 类似，但锁是直接加在方法上，锁对象是 Vector 实例本身。
代码示例：

java 复制代码

public synchronized void add(int index, E element) {
    insertElementAt(element, index);
}

3.2 Collections.synchronizedList（外层同步）

实现：如上所述，通过包装器模式在外层加锁。
特点：比 Vector 更灵活，可以包装任意 List 实现。

3.3 CopyOnWriteArrayList（写时复制）

实现：写操作复制数组，读操作无锁（详见前文）。
特点：不依赖传统同步，适合读多写少场景。

3.4 ConcurrentLinkedQueue（非List，但相关并发容器）

实现：基于 CAS（Compare-And-Swap）实现的无锁队列。
特点：虽然不是 List，但展示了无锁并发设计的思路。

3.5 自定义同步

实现：开发者可以用 synchronized 块或 ReentrantLock 手动同步普通 List。
特点：粒度可控，但需要自己保证正确性。

Java 的同步方式大致可以分为：

粗粒度锁 ：如 Vector 和 SynchronizedList，锁住整个对象。
写时复制 ：如 CopyOnWriteArrayList，无锁读。
无锁并发：如 CAS 或原子操作，适用于特定场景。

4. 为什么说它们的粒度粗？

面试官提到的"粒度粗"，指的是 Vector 和 Collections.synchronizedList 的锁范围较大。原因如下：

4.1 锁住整个对象

现象：每次操作（读或写）都锁住整个 List，其他线程无法并发执行任何操作。
影响：即使是无关的读操作（get(0) 和 get(100)），也必须串行执行，降低了并发性。

4.2 无读写分离

现象：读和写操作都用同一把锁，没有区分读读并发或读写并发。
对比：CopyOnWriteArrayList 通过写时复制实现读无锁，ReentrantReadWriteLock 可以实现读写锁分离，而 SynchronizedList 没有这种优化。

4.3 方法级同步

现象：锁的范围覆盖整个方法调用，即使方法内部可能只有一小部分需要保护。
结果：增加了不必要的同步开销。

4.4 迭代问题

现象：迭代器本身无同步，需要外部加锁，进一步放大锁粒度。
对比：CopyOnWriteArrayList 的快照迭代器无需额外锁。

粗粒度锁的本质 ：为了简单和通用性，牺牲了并发性能。SynchronizedList 和 Vector 的设计目标是"线程安全优先"，而不是"高并发优化"。

5. 面试回答优化

如果再遇到这个问题，我的回答会这样组织：

实现逻辑 ：SynchronizedList 通过代理模式，在所有方法上加 synchronized 块，锁住整个对象。
同步方式 ：列举 Vector（方法同步）、SynchronizedList（包装同步）、CopyOnWriteArrayList（写时复制）等，简述特点。
粗粒度原因 ：锁范围大、无读写分离、方法级同步，举例对比 CopyOnWriteArrayList 的无锁读。
扩展：提到现代并发设计的趋势（如读写锁、CAS），体现知识深度。

6. 总结

Collections.synchronizedList 的实现简单直接，通过外层同步保证线程安全，但锁粒度粗导致并发性能不高。理解其原理和局限性，不仅能回答面试问题，还能指导我们在实际开发中选择更合适的并发容器，比如读多写少时用 CopyOnWriteArrayList，高并发时考虑无锁设计。这次复盘让我对同步策略有了更深的认识！