Java中安全更新final ConcurrentHashMap的策略

private final Map<String, Set<EventMapping>> registeredEvents = new ConcurrentHashMap<>();

public void updateEvents(Map<String, Set<EventMapping>> newRegisteredEntries) {
    if (MapUtils.isNotEmpty(newRegisteredEntries)) {
        registeredEvents.clear(); // 问题点1：清空操作
        registeredEvents.putAll(newRegisteredEntries); // 问题点2：填充操作
    }
}

private final Map<String, Set<EventMapping>> registeredEvents = new ConcurrentHashMap<>();

public void updateEventsSafely(Map<String, Set<EventMapping>> newRegisteredEntries) {
    if (MapUtils.isNotEmpty(newRegisteredEntries)) {
        // 1. 记录旧键，用于后续删除不再存在的条目
        Set<String> oldKeys = new HashSet<>(registeredEvents.keySet());

        // 2. 将新条目添加到Map中，会覆盖现有键的值
        registeredEvents.putAll(newRegisteredEntries);

        // 3. 找出不再存在于新数据中的旧键
        oldKeys.removeAll(newRegisteredEntries.keySet());

        // 4. 移除不再需要的旧键
        oldKeys.forEach(registeredEvents::remove);
    }
}

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;

public class EventMappingManager {

    // 使用AtomicReference来原子地管理Map的引用
    private final AtomicReference<Map<String, Set<EventMapping>>> registeredEventsRef =
            new AtomicReference<>(Collections.emptyMap()); // 初始可以为空或预设值

    // 获取当前活动的事件映射
    public Map<String, Set<EventMapping>> getRegisteredEvents() {
        return registeredEventsRef.get(); // 读操作直接获取当前引用，无需加锁，性能高
    }

    // 原子地更新事件映射
    public void updateEventsAtomically(Map<String, Set<EventMapping>> newRegisteredEntries) {
        // 1. 构建一个新的不可变Map，包含所有最新数据
        // 注意：这里使用HashMap作为构建器，如果newRegisteredEntries是可变的，需要深拷贝
        Map<String, Set<EventMapping>> newMap = new HashMap<>(newRegisteredEntries);
        // 如果希望Map本身不可修改，可以包装成Collections.unmodifiableMap
        Map<String, Set<EventMapping>> immutableNewMap = Collections.unmodifiableMap(newMap);

        // 2. 使用CAS操作原子地更新引用
        // oldMap 是当前旧的引用，如果多个线程同时更新，只有一个能成功
        registeredEventsRef.set(immutableNewMap);

        // 另一种更严谨的更新方式是使用compareAndSet，但对于全量替换场景，set通常足够
        // 除非你需要基于旧值进行计算新值并保证原子性
        // registeredEventsRef.compareAndSet(oldMap, immutableNewMap); 
    }

    // 示例用法
    public static void main(String[] args) {
        EventMappingManager manager = new EventMappingManager();

        // 首次加载
        Map<String, Set<EventMapping>> initialData = new ConcurrentHashMap<>();
        initialData.put("eventA", Collections.singleton(new EventMapping("type1", "action1")));
        manager.updateEventsAtomically(initialData);
        System.out.println("Initial Map: " + manager.getRegisteredEvents());

        // 模拟高并发读操作
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Reader 1: " + manager.getRegisteredEvents().get("eventA"));
            }
        }).start();

        // 模拟更新操作
        new Thread(() -> {
            try {
                Thread.sleep(250); // 稍等片刻，让读线程先运行
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            Map<String, Set<EventMapping>> updatedData = new ConcurrentHashMap<>();
            updatedData.put("eventA", Collections.singleton(new EventMapping("type2", "action2")));
            updatedData.put("eventB", Collections.singleton(new EventMapping("type3", "action3")));
            manager.updateEventsAtomically(updatedData);
            System.out.println("Map Updated. New Map: " + manager.getRegisteredEvents());
        }).start();
    }

    static class EventMapping {
        String type;
        String action;

        public EventMapping(String type, String action) {
            this.type = type;
            this.action = action;
        }

        @Override
        public String toString() {
            return "{" + type + "," + action + "}";
        }
    }
}