- **正确答案**：ArrayList 本身不是线程安全的。为了保证其线程安全性，可以通过以下几种方式实现：使用 Collections.synchronizedList 包装、使用 CopyOnWriteArrayList、或者在访问时手动加锁（如 synchronized 或 ReentrantLock）。 - **解答思路**：首先要明确 ArrayList 的非线程安全特性：当多个线程同时修改 ArrayList 时，可能会导致数据不一致、ConcurrentModificationException 等问题。因此需要引入同步机制。常见的解决方案有： 1. 使用 Collections.synchronizedList(new ArrayList<>()) 返回一个线程安全的 List。 2. 使用并发包 java.util.concurrent 中的 CopyOnWriteArrayList，适用于读多写少的场景。 3. 在访问 ArrayList 时手动加锁，例如使用 synchronized 关键字或 Lock 接口（如 ReentrantLock）来控制并发访问。 - **深度知识讲解**： **ArrayList 底层结构**： ArrayList 是基于数组实现的动态数组，内部维护一个 Object[] elementData 来存储元素。当容量不足时会进行扩容（通常是当前容量的 1.5 倍）。由于扩容和添加操作没有同步机制，多个线程并发操作时容易导致数据不一致或抛出异常。 **线程不安全的表现**： - 多个线程同时 add 元素时可能导致数组越界或覆盖其他元素。 - 迭代过程中如果被修改，会抛出 ConcurrentModificationException。 **解决方案详解**： 1. **Collections.synchronizedList**：该方法返回一个同步代理对象，它对所有 public 方法加上 synchronized 锁。例如 get、set、add、remove 等方法都会被同步。这种方式适合写操作较多的场景，但性能较低，因为每次调用都要获取锁。 2. **CopyOnWriteArrayList**：属于写时复制的并发容器。每次写操作（add、set、remove）都会创建一个新的数组副本，并替换原数组。读操作无需加锁，适合读多写少的场景（如配置管理、事件监听器列表等）。缺点是写操作代价高，且不能保证实时一致性。 3. **手动加锁**：如果你希望更细粒度地控制同步逻辑，可以使用 synchronized 或 ReentrantLock 对代码块进行加锁。例如： ```java List list = new ArrayList<>(); // 写操作 synchronized (list) { list.add("item"); } // 读操作 synchronized (list) { for (String s : list) { System.out.println(s); } } ``` 或者使用 ReentrantLock： ```java ReentrantLock lock = new ReentrantLock(); List list = new ArrayList<>(); lock.lock(); try { list.add("item"); } finally { lock.unlock(); } ``` 手动加锁的好处是可以根据业务需求灵活控制同步范围，避免不必要的锁竞争。 **适用场景对比**： | 方式 | 优点 | 缺点 | 适用场景 | |---|---|---|---| | Collections.synchronizedList | 使用简单 | 性能差，粗粒度锁 | 写操作频繁但并发不高 | | CopyOnWriteArrayList | 读操作无锁，性能好 | 写操作开销大，内存占用高 | 读多写少 | | 手动加锁 | 控制灵活 | 实现复杂 | 需要精细控制同步逻辑 | **扩展知识点**： - Java 中的线程安全集合还包括 ConcurrentHashMap、ConcurrentLinkedQueue 等，都是 java.util.concurrent 包下的高性能并发容器。 - 并发编程中还应注意可见性、有序性和原子性问题。volatile、synchronized 和 CAS 操作是解决这些问题的核心机制。 - 在使用迭代器遍历线程安全的 ArrayList 时，仍需外部同步以防止结构修改异常。 - **代码示例**：示例一：使用 Collections.synchronizedList ```java import java.util.*; public class SafeArrayListExample { public static void main(String[] args) { List list = Collections.synchronizedList(new ArrayList<>()); new Thread(() -> { for (int i = 0; i < 1000; i++) { list.add("A" + i); } }).start(); new Thread(() -> { for (int i = 0; i < 1000; i++) { list.add("B" + i); } }).start(); // 等待线程结束 try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("List size: " + list.size()); } } ``` 示例二：使用 CopyOnWriteArrayList ```java import java.util.concurrent.CopyOnWriteArrayList; public class CopyOnWriteExample { public static void main(String[] args) { List list = new CopyOnWriteArrayList<>(); new Thread(() -> { for (int i = 0; i < 1000; i++) { list.add("X" + i); } }).start(); new Thread(() -> { for (int i = 0; i < 1000; i++) { list.add("Y" + i); } }).start(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("List size: " + list.size()); } } ``` 示例三：使用 ReentrantLock ```java import java.util.*; import java.util.concurrent.locks.ReentrantLock; public class ManualLockExample { private static final ReentrantLock lock = new ReentrantLock(); private static List list = new ArrayList<>(); public static void main(String[] args) { Runnable task = () -> { for (int i = 0; i < 1000; i++) { lock.lock(); try { list.add(Thread.currentThread().getName() + "-" + i); } finally { lock.unlock(); } } }; new Thread(task, "Thread-A").start(); new Thread(task, "Thread-B").start(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("List size: " + list.size()); } } ```

腾讯天美一面凉经

全站热榜

创作者周榜