线程安全设计模式：不可变对象、Thread-safe Singleton、生产者-消费者

public final class OrderSnapshot {           // 规则 1：final 类，禁止继承
    private final String orderId;                // 规则 2：所有字段 private final
    private final BigDecimal totalAmount;
    private final LocalDateTime createTime;
    private final List<String> items;         // 可变引用字段！规则 3 的重点

    public OrderSnapshot(String id, BigDecimal amt,
                        LocalDateTime time, List<String> items) {
        this.orderId = id;
        this.totalAmount = amt;
        this.createTime = time;
        this.items = List.copyOf(items);     // 规则 3：防御性拷贝（Defensive Copy）
    }

    // 规则 4：只提供 getter，不提供 setter
    public String getOrderId()          { return orderId; }
    public BigDecimal getTotalAmount()  { return totalAmount; }
    public List<String> getItems()     { return items; } // copyOf 返回的就是不可变 List
}

// ✗ 错误：入口没拷贝，getter 直接泄漏内部引用
public class BadConfig {
    private final List<String> blackList;
    public BadConfig(List<String> list) { this.blackList = list; } // 外部还能改！
    public List<String> getBlackList()   { return blackList; }      // 内部被泄漏！
}

// ✓ 正确：入口 copyOf，getter 返回的本来就是不可变 List
public class SafeConfig {
    private final List<String> blackList;
    public SafeConfig(List<String> list) {
        this.blackList = List.copyOf(list);      // 入口拷贝一份，与外部彻底切断
    }
    public List<String> getBlackList()   { return blackList; }  // 内部本身就是不可变 List
}

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {}
    public static EagerSingleton getInstance() { return INSTANCE; }
}  // 优点：简单可靠、天然线程安全 | 缺点：类一加载就创建，可能白占内存

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    public static synchronized LazySingleton getInstance() {
        if (instance == null) instance = new LazySingleton();
        return instance;
    }
}  // 优点：延迟加载 | 缺点：每次调用都过锁，高并发下是热点

public class DclSingleton {
    private static volatile DclSingleton instance; // 必须 volatile！
    private DclSingleton() {}
    public static DclSingleton getInstance() {
        if (instance == null) {                     // 第一次检查（无锁，快路径）
            synchronized (DclSingleton.class) {
                if (instance == null)                 // 第二次检查（有锁，慢路径）
                    instance = new DclSingleton();
            }
        }
        return instance;
    }
}

public class HolderSingleton {
    private HolderSingleton() {}
    private static class Holder {
        private static final HolderSingleton INSTANCE = new HolderSingleton();
    }
    public static HolderSingleton getInstance() { return Holder.INSTANCE; }
}  // 延迟加载 + ClassLoader 保证线程安全 + 无锁

public enum ConfigSingleton {
    INSTANCE;                                    // 唯一的实例，JVM 保证

    private final Map<String, String> cache =
            new ConcurrentHashMap<>();            // 单例里可以带自己的状态

    public String get(String key)  { return cache.get(key); }
    public void put(String key, String value) { cache.put(key, value); }
}
// 使用：ConfigSingleton.INSTANCE.get("timeout");

// ✗ 定时炸弹：单例里的可变字段被多线程乱改
public enum Counter {
    INSTANCE;
    private int count;                        // 可变状态！多个线程 ++count 会丢更新
    public int incr() { return ++count; }
}

// ✓ 正确：状态要么外移，要么用并发原子工具
public enum Counter {
    INSTANCE;
    private final AtomicLong count = new AtomicLong();  // 原子自增，无锁且安全
    public long incr() { return count.incrementAndGet(); }
}

// 攻击：反射调用私有构造器，绕过 getInstance
Constructor<EagerSingleton> c =
        EagerSingleton.class.getDeclaredConstructor();
c.setAccessible(true);
EagerSingleton second = c.newInstance();   // 第二个实例诞生！

// 防御：构造器里加一道"只允许创建一次"的检查（加锁保证并发安全）
private static boolean created;
private EagerSingleton() {
    synchronized (EagerSingleton.class) {
        if (created) throw new IllegalStateException("单例已被创建！");
        created = true;
    }
}

import java.util.concurrent.*;

public class ProducerConsumerDemo {
    private static final String POISON = "POISON";  // 毒丸：通知消费者下班

    public static void main(String[] args) throws Exception {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(10); // 有界队列
        ExecutorService pool = Executors.newFixedThreadPool(4);

        // 2 个生产者：各产 5 条，产完投一颗毒丸
        for (int p = 1; p <= 2; p++) {
            final int no = p;
            pool.submit(() -> {
                try {
                    for (int i = 1; i <= 5; i++) {
                        queue.put("P" + no + "-item-" + i); // 满时阻塞
                    }
                    queue.put(POISON);  // 告诉消费者：没有更多数据了
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();  // 恢复中断标志
                }
            });
        }

        // 2 个消费者：吃到毒丸就退出
        for (int c = 1; c <= 2; c++) {
            final int no = c;
            pool.submit(() -> {
                try {
                    while (true) {
                        String data = queue.take();       // 空时阻塞
                        if (POISON.equals(data)) break; // 下班！
                        System.out.println("C" + no + " 消费: " + data);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        pool.shutdown();                              // 不再接收新任务
        pool.awaitTermination(10, TimeUnit.SECONDS); // 等全部任务跑完
    }
}

// synchronizedMap：读和读之间也互斥！100 线程读也要排队
Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());

// ConcurrentHashMap：100 线程可以同时读，互不影响
ConcurrentMap<String, String> chm = new ConcurrentHashMap<>();
// get()  → 无锁读取（volatile 保证可见性）
// put()  → CAS + synchronized（只锁单个桶节点）

// 注意：CHM 的 size()/isEmpty() 是弱一致的，别拿来做精确判断

public boolean add(E e) {
    synchronized (lock) {                    // ① 写才加锁
        Object[] es = getArray();             // ② 拿到当前数组
        Object[] newElements = Arrays.copyOf(es, es.length + 1);
        newElements[es.length] = e;              // ③ 复制 + 修改（原数组不动）
        setArray(newElements);                   // ④ volatile 替换引用，读线程立刻可见
        return true;
    }
}
// get(i) 无锁：直接读 volatile 数组的某个下标

public class TraceContext {
    private static final ThreadLocal<String> TRACE_ID = new ThreadLocal<>();

    public static void set(String id)  { TRACE_ID.set(id); }
    public static String get()       { return TRACE_ID.get(); }
    public static void clear()     { TRACE_ID.remove(); }   // 必须清理！
}

// 拦截器里：进入请求时 set，处理完 finally 里 remove
try {
    TraceContext.set(requestId);   // 本线程往后的日志都能带上 traceId
    handle(request);
} finally {
    TraceContext.clear();          // 防止线程池复用后"串号"
}

// ✘ 反面：在 synchronized 里做 IO
public synchronized void processOrder(Order order) {
    validateOrder(order);              // 需要锁
    updateInventory(order);            // 需要锁
    sendEmail(order.getUserEmail());   // 发邮件可能 2 秒！其他线程干等
}

// ✔ 正面：只锁必要部分
public void processOrder(Order order) {
    synchronized (this) {
        validateOrder(order);
        updateInventory(order);
    }
    sendEmail(order.getUserEmail());   // IO 移到锁外
}