线程安全的数据集合

线程安全的数据集合是专为多线程环境设计的集合类，能够在并发操作中保证数据的一致性和安全性。以下是一些常见的线程安全集合及其特点和使用场景。

常见线程安全集合

ConcurrentHashMap ConcurrentHashMap 是一种高效的线程安全哈希表，采用分段锁机制，将哈希表分为多个段，每个段独立加锁，从而提高并发性能。它适用于高频读写操作的场景。示例代码：

java 复制代码

import java.util.concurrent.ConcurrentHashMap;
public class Example {
   public static void main(String[] args) {
       ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
       Thread thread1 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               map.put("Key" + i, i);
           }
       });
       Thread thread2 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               map.put("Key" + i, i);
           }
       });
       thread1.start();
       thread2.start();
       try {
           thread1.join();
           thread2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("Map size: " + map.size());
   }
}

CopyOnWriteArrayList CopyOnWriteArrayList 是基于写时复制的线程安全动态数组，适用于读多写少的场景。写操作会创建新数组，读操作无需加锁，性能较高。示例代码：

java 复制代码

import java.util.concurrent.CopyOnWriteArrayList;
public class Example {
   public static void main(String[] args) {
       CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
       Thread thread1 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               list.add("Element" + i);
           }
       });
       Thread thread2 = new Thread(() -> {
           for (String element : list) {
               System.out.println(element);
           }
       });
       thread1.start();
       thread2.start();
       try {
           thread1.join();
           thread2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

ConcurrentLinkedQueue ConcurrentLinkedQueue 是基于无锁算法的线程安全队列，适用于高并发的生产者-消费者模型。它通过 CAS 操作实现线程安全。示例代码：

java 复制代码

import java.util.concurrent.ConcurrentLinkedQueue;
public class Example {
   public static void main(String[] args) {
       ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
       Thread producer = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               queue.offer("Element" + i);
           }
       });
       Thread consumer = new Thread(() -> {
           while (!queue.isEmpty()) {
               System.out.println(queue.poll());
           }
       });
       producer.start();
       consumer.start();
       try {
           producer.join();
           consumer.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

使用场景与选择

高频读写：选择 ConcurrentHashMap，因其分段锁机制能有效减少锁竞争。
读多写少：选择 CopyOnWriteArrayList，因其写时复制机制能提供高效的读操作。
生产者 - 消费者模型：选择 ConcurrentLinkedQueue，因其无锁设计能提供高吞吐量。

线程安全集合的选择应根据具体的并发场景和性能需求进行权衡。