自定义Java缓存机制的并发执行与同步问题排查及修复

一、现有代码的潜在问题 #

你用synchronized方法锁住了缓存操作，但底层依赖的HashMap并非线程安全容器——虽然同步方法能保证同一时间只有一个线程操作缓存，但如果缓存被意外暴露给外部、或者代码中存在未被同步的缓存操作，就可能出现条目覆盖、获取null的异常。另外，手动实现的“不存在则添加”逻辑，不如原子操作可靠。

二、具体修复方案 #

1. 推荐：改用ConcurrentHashMap（最优解）

Java并发包提供的ConcurrentHashMap是专为高并发场景设计的线程安全哈希表，内置原子操作，无需额外同步，性能比手动同步HashMap好得多：

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class CacheManager {
    // 用final修饰，避免缓存实例被意外替换
    private final Map<String, Object> cache = new ConcurrentHashMap<>();

    // 用putIfAbsent原子操作替代手动判断+put，保证逻辑原子性
    public void addToCache(String key, Object value) {
        cache.putIfAbsent(key, value);
    }

    public Object getFromCache(String key) {
        return cache.get(key);
    }

    public Object removeFromCache(String key) {
        return cache.remove(key);
    }
}

putIfAbsent方法会原子性地完成“检查key是否存在→不存在则添加”的逻辑，完全避免竞态条件。

2. 若必须保留HashMap

如果因为某些原因要继续用HashMap，需确保：

• 缓存实例用final修饰，防止被意外替换
• 所有缓存操作都被正确同步（包括任何可能的修改/读取操作）

import java.util.HashMap;
import java.util.Map;

public class CacheManager {
    private final Map<String, Object> cache = new HashMap<>();

    public synchronized void addToCache(String key, Object value) {
        if (!cache.containsKey(key)) {
            cache.put(key, value);
        }
    }

    public synchronized Object getFromCache(String key) {
        return cache.get(key);
    }

    public synchronized Object removeFromCache(String key) {
        return cache.remove(key);
    }
}

同时要绝对避免将cache实例暴露给外部（比如不要提供getter方法返回cache），防止外部线程绕过同步直接操作缓存。

三、缓存场景的最佳实践 #

• 优先用Java并发包的线程安全容器：ConcurrentHashMap、ConcurrentSkipListMap等经过工业级验证，比手动同步更可靠、性能更好。
• 用原子操作替代手动同步逻辑：比如ConcurrentHashMap.computeIfAbsent，可以在key不存在时原子性地创建并添加昂贵对象（比如数据库连接），避免多个线程重复创建：

  public Object getOrCreateConnection(String key) {
      return cache.computeIfAbsent(key, k -> createExpensiveConnection());
  }
  

• 添加缓存过期/淘汰策略：对于数据库连接这类资源，要设置过期时间或最大容量，防止内存溢出。可以结合定时任务清理过期条目，或者用LRU（最近最少使用）策略淘汰旧条目。
• 保证缓存对象自身的线程安全：如果缓存的对象（比如数据库连接）不是线程安全的，要确保每个线程获取到独立实例，或者对对象的操作额外同步。
• 最小化锁粒度：如果必须手动同步，不要锁住整个对象，而是锁住缓存实例本身，减少锁竞争：

  public void addToCache(String key, Object value) {
      synchronized (cache) {
          if (!cache.containsKey(key)) {
              cache.put(key, value);
          }
      }
  }
  

• 防止缓存穿透/雪崩：对不存在的key可以缓存空值（短时间），或者用本地锁避免多个线程同时创建同一昂贵对象，防止缓存失效时大量请求直接打向数据库。

内容的提问来源于stack exchange，提问作者Mustafa Abudalu