【Java并发】常用的线程安全集合类详解

// 多线程操作普通HashMap，可能导致死循环、数据丢失
Map<String, Integer> map = new HashMap<>();

// 线程1
new Thread(() -> {
    for (int i = 0; i < 10000; i++) {
        map.put("key" + i, i);
    }
}).start();

// 线程2
new Thread(() -> {
    for (int i = 10000; i < 20000; i++) {
        map.put("key" + i, i);
    }
}).start();

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// 基本操作与HashMap相同
map.put("apple", 1);
map.get("apple");
map.remove("apple");

// 原子操作方法
map.putIfAbsent("banana", 2);       // 不存在才放入
map.computeIfAbsent("orange", k -> 3);  // 不存在才计算并放入
map.computeIfPresent("apple", (k, v) -> v + 1);  // 存在才更新
map.merge("apple", 1, Integer::sum);  // 合并值

// 1. 计数器
ConcurrentHashMap<String, LongAdder> counters = new ConcurrentHashMap<>();
counters.computeIfAbsent("pageView", k -> new LongAdder()).increment();

// 2. 缓存
ConcurrentHashMap<String, Object> cache = new ConcurrentHashMap<>();
Object value = cache.computeIfAbsent(key, k -> loadFromDB(k));

// 3. 去重统计
ConcurrentHashMap<String, Boolean> seen = new ConcurrentHashMap<>();
if (seen.putIfAbsent(item, Boolean.TRUE) == null) {
    // 第一次看到这个item
}

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// 添加元素（会复制整个数组）
list.add("apple");
list.addAll(Arrays.asList("banana", "orange"));

// 读取元素（无锁，直接访问）
String first = list.get(0);
for (String item : list) {
    System.out.println(item);
}

// 遍历时可以安全地修改
for (String item : list) {
    if (item.equals("apple")) {
        list.remove(item);  // 不会抛出ConcurrentModificationException
    }
}

// 1. 监听器列表（读多写少）
CopyOnWriteArrayList<EventListener> listeners = new CopyOnWriteArrayList<>();

public void addListener(EventListener listener) {
    listeners.add(listener);  // 写操作少
}

public void fireEvent(Event event) {
    for (EventListener listener : listeners) {  // 读操作多
        listener.onEvent(event);
    }
}

// 2. 配置列表（启动时写入，运行时只读）
CopyOnWriteArrayList<String> blacklist = new CopyOnWriteArrayList<>();
// 启动时加载
blacklist.addAll(loadBlacklistFromDB());
// 运行时只读
boolean blocked = blacklist.contains(userId);

CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();
set.add("apple");
set.add("apple");  // 重复元素不会添加
System.out.println(set.size());  // 1

ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

// 入队
queue.offer("task1");
queue.add("task2");

// 出队
String task = queue.poll();  // 返回并移除头部，空则返回null
String head = queue.peek();  // 只查看头部，不移除

// 创建容量为100的队列
ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(100);

// 生产者
new Thread(() -> {
    try {
        queue.put("product");  // 队列满时阻塞
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// 消费者
new Thread(() -> {
    try {
        String product = queue.take();  // 队列空时阻塞
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// 无界队列（实际上界是Integer.MAX_VALUE）
LinkedBlockingQueue<String> unbounded = new LinkedBlockingQueue<>();

// 有界队列
LinkedBlockingQueue<String> bounded = new LinkedBlockingQueue<>(1000);

// 按任务优先级排序
PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>(
    11,
    Comparator.comparingInt(Task::getPriority)
);

queue.put(new Task("low", 3));
queue.put(new Task("high", 1));
queue.put(new Task("medium", 2));

queue.take();  // 返回high（优先级1最高）

class DelayedTask implements Delayed {
    private String name;
    private long executeTime;

    public DelayedTask(String name, long delayMs) {
        this.name = name;
        this.executeTime = System.currentTimeMillis() + delayMs;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long diff = executeTime - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.executeTime, ((DelayedTask) o).executeTime);
    }
}

// 使用
DelayQueue<DelayedTask> queue = new DelayQueue<>();
queue.put(new DelayedTask("task1", 5000));  // 5秒后执行
queue.put(new DelayedTask("task2", 1000));  // 1秒后执行

DelayedTask task = queue.take();  // 阻塞直到最近的任务到期

SynchronousQueue<String> queue = new SynchronousQueue<>();

// 生产者线程
new Thread(() -> {
    try {
        queue.put("data");  // 阻塞，直到有消费者take
        System.out.println("已交付");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// 消费者线程
new Thread(() -> {
    try {
        Thread.sleep(1000);
        String data = queue.take();  // 直接从生产者手中获取
        System.out.println("收到: " + data);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

ConcurrentSkipListMap<Integer, String> map = new ConcurrentSkipListMap<>();

map.put(3, "three");
map.put(1, "one");
map.put(2, "two");

// 有序遍历
map.forEach((k, v) -> System.out.println(k + "=" + v));
// 输出：1=one, 2=two, 3=three

// 范围操作
SortedMap<Integer, String> subMap = map.subMap(1, 3);  // [1, 3)
map.firstKey();   // 1
map.lastKey();    // 3
map.higherKey(2); // 3
map.lowerKey(2);  // 1

ConcurrentSkipListSet<Integer> set = new ConcurrentSkipListSet<>();
set.add(3);
set.add(1);
set.add(2);

// 有序遍历
for (Integer i : set) {
    System.out.println(i);  // 1, 2, 3
}

// 范围操作
set.headSet(2);  // [1]
set.tailSet(2);  // [2, 3]