《Java 并发编程·JUC 源码与容器》6.3 并发集合选型矩阵

List<String> isbns = new ArrayList<>(map.keySet());
Collections.sort(isbns);          // 每次查询 O(n log n)

需要按 key 排序 / 范围查询 / 前驱后继？
├── 是 → ConcurrentSkipListMap（点查也走它，别双写）
└── 否
    ├── 是 Map，且只需点查？
    │   └── 是 → ConcurrentHashMap
    ├── 是 List/Set，元素 < 几百，写极冷（配置、监听器、路由表）？
    │   └── 是 → CopyOnWriteArrayList / CopyOnWriteArraySet
    ├── 是队列，需要“满/空时阻塞”？
    │   ├── 有界且要公平 → ArrayBlockingQueue
    │   └── 高吞吐、生产消费都猛 → LinkedBlockingQueue（务必显式给容量）
    ├── 是队列，只是多线程传递、不想阻塞？
    │   └── 是 → ConcurrentLinkedQueue / ConcurrentLinkedDeque
    └── 以上都不是（需要复合原子操作、需要跨结构一致）
        └── 用锁 + 普通集合，把临界区写清楚（卷一第 9 章）

package com.plume.conc.core;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CopyOnWriteArrayList;

/** 选型辅助：把“为什么选它”固化成可读的决策。 */
public final class CollectionChoice {
    public enum Need { ORDERED_MAP, POINT_MAP, COLD_LIST, NONE }

    private CollectionChoice() {}

    public static String pick(Need need, int size, int writesPerMinute) {
        return switch (need) {
            case ORDERED_MAP -> "ConcurrentSkipListMap";
            case POINT_MAP -> "ConcurrentHashMap";
            case COLD_LIST -> (size < 500 && writesPerMinute < 1)
                    ? "CopyOnWriteArrayList"
                    : "synchronizedList 或换数据结构";
            case NONE -> "加锁 + 普通集合";
        };
    }

    public static void main(String[] args) {
        System.out.println(pick(Need.COLD_LIST, 3, 0));        // CopyOnWriteArrayList
        System.out.println(pick(Need.COLD_LIST, 50_000, 600)); // synchronizedList 或换数据结构
        System.out.println(pick(Need.ORDERED_MAP, 100_000, 1000)); // ConcurrentSkipListMap
    }
}

package com.plume.conc.core;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/** 误选版本：用写时复制承担高写频的索引。 */
public final class CowIsbnIndex {
    public record Entry(String isbn, String shelf, int stock) {}

    private final CopyOnWriteArrayList<Entry> entries = new CopyOnWriteArrayList<>();

    public Entry find(String isbn) {
        for (Entry e : entries) if (e.isbn().equals(isbn)) return e;
        return null;
    }

    public void update(Entry e) {
        entries.removeIf(old -> old.isbn().equals(e.isbn()));  // 一次全量复制
        entries.add(e);                                        // 再一次全量复制
    }

    public List<Entry> range(String from, String to) {
        List<Entry> out = new ArrayList<>();
        for (Entry e : entries)
            if (e.isbn().compareTo(from) >= 0 && e.isbn().compareTo(to) < 0) out.add(e);
        out.sort((a, b) -> a.isbn().compareTo(b.isbn()));
        return out;
    }
}

== 索引更新一次的平均分配字节数（n=20000，本机）
CowIsbnIndex        162684 B/次
HybridIsbnIndex        596 B/次

package com.plume.conc.core;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;

/** 正解：点查走 CHM，有序区间走 CSLM；两个结构各自 CAS。 */
public final class HybridIsbnIndex {
    public record Entry(String isbn, String shelf, int stock) {}

    private final ConcurrentHashMap<String, Entry> byIsbn = new ConcurrentHashMap<>();
    private final ConcurrentSkipListMap<String, Entry> ordered = new ConcurrentSkipListMap<>();

    public Entry find(String isbn) { return byIsbn.get(isbn); }

    public void update(Entry e) {
        byIsbn.put(e.isbn(), e);      // 点查结构：O(1)
        ordered.put(e.isbn(), e);     // 有序结构：O(log n)
    }

    public List<Entry> range(String from, String to) {
        return new ArrayList<>(ordered.subMap(from, true, to, false).values());
    }
}