线程安全与线程不安全

线程安全的概念

线程安全：指当多个线程并发访问某个对象时，不会因为线程调度导致数据的不一致或数据污染，即能保证数据的完整性和正确性。
实现线程安全的方式：
1. 使用同步机制（如 synchronized 关键字或显式锁 ReentrantLock）。
2. 使用线程安全的数据结构（如 Vector、ConcurrentHashMap）。
3. 采用无锁的并发算法（如 Atomic 系列类）。

同步与异步的区别

同步：执行任务时，当前线程需要等待任务完成后才能继续进行。例如，调用一个方法后，方法完成返回结果，调用者才能继续执行。
- 优点：逻辑简单，易于理解。
- 缺点：等待任务完成时可能造成性能损失。
异步：执行任务时，当前线程可以继续执行其他任务，而无需等待任务完成。任务完成后会通过回调或通知机制处理结果。
- 优点：效率高，能更好地利用资源。
- 缺点：逻辑复杂，增加调试难度。

简单示例：

java">// 同步方法
public String fetchDataSync() {return "Data fetched synchronously";
}// 异步方法
public CompletableFuture<String> fetchDataAsync() {return CompletableFuture.supplyAsync(() -> "Data fetched asynchronously");
}

Java 的集合类分类及线程安全性

Java 的集合类主要分为两大接口：Collection 和 Map，下面详细列出：

1. Collection 接口的子接口

List 接口（有序、允许重复元素）
- 线程不安全：
  - ArrayList：底层是动态数组，读写快，线程不安全。
  - LinkedList：底层是链表，插入/删除快，线程不安全。
- 线程安全：
  - Vector：方法加了 synchronized，线程安全，但性能差。
  - Collections.synchronizedList：通过 Collections 工具类将 List 包装为线程安全版本。
Set 接口（无序，不允许重复元素）
- 线程不安全：
  - HashSet：基于 HashMap 实现，线程不安全。
  - TreeSet：基于红黑树实现，线程不安全。
- 线程安全：
  - Collections.synchronizedSet：将 Set 包装成线程安全。
Queue 接口（队列结构，支持 FIFO 等特性）
- 线程不安全：
  - LinkedList（也实现了 Queue）。
  - PriorityQueue：基于堆的优先队列。
- 线程安全：
  - ConcurrentLinkedQueue：非阻塞队列，适合高并发场景。
  - BlockingQueue（如 ArrayBlockingQueue, LinkedBlockingQueue）：阻塞队列，适合生产者-消费者模型。

2. Map 接口

线程不安全：
- HashMap：无序的键值对集合，线程不安全。
- TreeMap：有序键值对集合，线程不安全。
线程安全：
- HashTable：早期线程安全的 Map 实现，效率低，不推荐使用。
- ConcurrentHashMap：分段锁机制，支持高并发访问，推荐使用。
- Collections.synchronizedMap：通过工具类包装 Map 为线程安全版本。

线程安全集合的实现方式

内置同步机制：
- 例如 Vector 和 HashTable，在每个方法上都加了 synchronized 关键字。
- 缺点：粒度大，性能较低。

同步包装器：

使用 Collections.synchronizedXxx 包装非线程安全集合，返回线程安全的包装类。

示例：

java">List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Map<Integer, String> synchronizedMap = Collections.synchronizedMap(new HashMap<>());

并发集合：
- 例如 ConcurrentHashMap 和 ConcurrentLinkedQueue，采用了更细粒度的锁（如分段锁或无锁算法）。
- 优点：高效，适合高并发场景。

总结

线程安全：保证多线程并发访问时的正确性和一致性。
同步与异步：
- 同步：任务依次完成，简单但效率低。
- 异步：任务并发执行，效率高但逻辑复杂。
集合类线程安全性：
- 常用线程不安全集合：ArrayList, HashMap, HashSet。
- 常用线程安全集合：Vector, ConcurrentHashMap, Collections.synchronizedList。

推荐使用并发集合（如 ConcurrentHashMap），尽量避免老旧的线程安全集合（如 Vector、HashTable）。

Java 中的某些集合类（如 ArrayList, HashMap 等）是线程不安全的，因为它们没有在内部实现同步机制。如果在多线程环境中多个线程并发访问这些集合，会因为数据竞争或操作冲突导致数据不一致或不可预测的行为。下面具体说明 为什么它们是线程不安全的。

线程不安全的原因

1. 缺少同步机制

这些集合类的方法中没有对关键操作（如插入、删除、读取、更新等）进行同步控制，多个线程可以同时访问和修改共享数据，可能导致数据的竞争。例如：

ArrayList 示例：
假设两个线程同时向同一个 ArrayList 添加数据：
```
java">List<Integer> list = new ArrayList<>();Thread t1 = new Thread(() -> list.add(1));
Thread t2 = new Thread(() -> list.add(2));t1.start();
t2.start();
```
两个线程可能同时对内部的数组进行写操作，如果 ArrayList 内部的数组需要扩容，而扩容操作和写操作之间没有同步，可能导致如下问题：
- 新添加的数据被覆盖；
- 扩容时拷贝的数据不完整；
- 数据结构被破坏，抛出异常。
HashMap 示例：
假设多个线程同时修改一个 HashMap，可能导致：
- 数据丢失：线程 A 和线程 B 同时插入不同的键值对，但最终可能只保存了一个线程的结果。
- 死循环（在早期 Java 版本中）：多个线程同时修改哈希桶，可能导致链表结构损坏。

2. 竞态条件（Race Condition）

竞态条件是指当多个线程同时访问和修改共享资源时，结果依赖于线程的执行顺序，而这种顺序是不可控的。

示例：
两个线程同时调用 ArrayList.add() 方法时：
- 线程 A 读取当前的数组索引位置 size，准备写入新元素；
- 线程 B 也读取了相同的 size 值；
- 最终，两个线程都写入了相同的索引位置，导致数据覆盖。

3. 缺乏原子性

Java 集合类的一些操作不是原子性的。例如 ArrayList.add() 并不是一个原子操作，而是由多步操作组成的：

检查数组是否需要扩容；
将元素插入到数组的指定位置；
更新内部计数变量 size。

如果多个线程同时执行这些步骤，可能出现：

读写冲突：线程 A 在执行第 2 步时，线程 B 已经修改了 size，导致线程 A 的操作无效。
脏数据：一个线程可能读到了另一个线程写入了一半的数据。

线程不安全的常见问题

1. 数据丢失

多个线程同时对集合进行写操作，导致某些数据被覆盖或丢失。

java">List<Integer> list = new ArrayList<>();
IntStream.range(0, 1000).parallel().forEach(list::add);
System.out.println(list.size());  // 结果可能小于 1000

2. 数据结构损坏

当多个线程并发操作 HashMap 时，可能导致哈希桶结构被破坏（如链表被断开），从而抛出异常。

3. 并发修改异常

当一个线程正在迭代集合时，另一个线程修改了集合，可能抛出 ConcurrentModificationException。

java">List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
for (Integer num : list) {if (num == 2) {list.remove(num);  // 抛出异常}
}

如何解决线程不安全问题？

手动同步
- 使用 synchronized 关键字：
```
java">List<Integer> list = new ArrayList<>();
synchronized (list) {list.add(1);
}
```
- 缺点：每次操作都需要加锁，影响性能。
使用线程安全的集合
- 使用 Collections.synchronizedXxx 方法：
```
java">List<Integer> list = Collections.synchronizedList(new ArrayList<>());
```
- 使用并发集合（推荐）：
  - 如 CopyOnWriteArrayList, ConcurrentHashMap 等。
避免共享数据
- 将集合局部化，每个线程使用自己的集合，避免共享资源。