线程安全与线程不安全

线程安全的概念

• 线程安全：指当多个线程并发访问某个对象时，不会由于线程调度导致数据的不划一或数据污染，即能保证数据的完整性和精确性。
  
• 实现线程安全的方式：
  
  
  • 使用同步机制（如 synchronized 关键字或显式锁 ReentrantLock）。
    
  • 使用线程安全的数据布局（如 Vector、ConcurrentHashMap）。
    
  • 接纳无锁的并发算法（如 Atomic 系列类）。
    
  
  

---

同步与异步的区别

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

简朴示例：

1. // 同步方法
2. public String fetchDataSync() {
3.     return "Data fetched synchronously";
4. }
6. // 异步方法
7. public CompletableFuture<String> fetchDataAsync() {
8.     return CompletableFuture.supplyAsync(() -> "Data fetched asynchronously");
9. }

复制代码

---

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 包装非线程安全集合，返回线程安全的包装类。
    
  • 示例：
    1. List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());
    2. 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 添加数据：
  
  1. List<Integer> list = new ArrayList<>();
  3. Thread t1 = new Thread(() -> list.add(1));
  4. Thread t2 = new Thread(() -> list.add(2));
  6. t1.start();
  7. 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. 数据丢失

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

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

复制代码

2. 数据布局损坏

当多个线程并发操作 HashMap 时，可能导致哈希桶布局被粉碎（如链表被断开），从而抛出异常。
3. 并发修改异常

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

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

复制代码

---

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

• 手动同步
  
  
  
  • 使用 synchronized 关键字：
    1. List<Integer> list = new ArrayList<>();
    2. synchronized (list) {
    3.     list.add(1);
    4. }

    复制代码
  • 缺点：每次操作都需要加锁，影响性能。
    
  
  
• 使用线程安全的集合
  
  
  
  • 使用 Collections.synchronizedXxx 方法：
    1. List<Integer> list = Collections.synchronizedList(new ArrayList<>());

    复制代码
  • 使用并发集合（保举）：
    
    
    
    • 如 CopyOnWriteArrayList, ConcurrentHashMap 等。
      
    
    
  
  
• 制止共享数据
  
  
  
  • 将集合局部化，每个线程使用自己的集合，制止共享资源。
    
  
  

---

总结

• 线程不安全的根本缘故原由：集合类的操作不是原子性的，多个线程同时访问会导致竞态条件和数据不划一。
  
• 非线程安全集合：ArrayList, HashMap, HashSet 等。
  
• 解决方法：使用同步机制、线程安全集合或无锁并发编程。
  

线程安全是以性能为代价换取数据划一性的，因此在选择线程安全集合时，要根据具体的场景权衡效率和安全性。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。