本地进程缓存

本地进程缓存时使用本地的JVM资源去存储数数，减少数据库和redis等中间件的压力，并且远程中间件与进程之间传输数据会经过网络传输，会影响一定的性能，为了加快数据响应提高用户使用体感，我们可以引入本地进程缓存来加快进程响应速度。

但是本地进程缓存的资源有限，所以我们要考虑以最大收益来使用本地进程缓存，它的核心使用场景如下：

1.读多写少、可容忍短暂数据不一致的热点基础数据（字典、地区码、系统配置、公告、商品类目）

2.短期临时数据：接口防重、限流计数、验证码、临时 Token

3.二级缓存架构：Caffeine (本地进程缓存) → Redis → DB，加速热点查询、削峰

不适合：

1.强一致性核心业务：库存、订单、支付、账户余额、实时价格，本地进程缓存无法保证集群环境下的强一致性

2.全局共享状态：分布式会话、全局锁、全局 ID，因为本地进程缓存只能将数据保存在本地JVM,在微服务情形下无法实现全局共享状态

3.需要长期持久保存的数据

4.高频实时更新的数据

三种主流的实现方式

1.使用java原生 ConcurrentHashMap,线程安全、原生无依赖；无自动过期 / 容量淘汰，仅用于少量临时数据，可能会出现内存泄漏，需要谨慎防范

java 复制代码

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

public class SimpleLocalCache {
    // 全局进程内存缓存
    private static final Map<String, Object> LOCAL_CACHE = new ConcurrentHashMap<>();

    // 存入
    public static void put(String key, Object value) {
        LOCAL_CACHE.put(key, value);
    }

    // 读取
    public static Object get(String key) {
        return LOCAL_CACHE.get(key);
    }

    // 删除
    public static void remove(String key) {
        LOCAL_CACHE.remove(key);
    }

    // 清空
    public static void clear() {
        LOCAL_CACHE.clear();
    }

    public static void main(String[] args) {
        put("user:1001", "张三");
        System.out.println(get("user:1001"));
    }
}

2.Caffeine

java 复制代码

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;

import java.util.concurrent.TimeUnit;

public class CaffeineCacheDemo {
    public static void main(String[] args) {
        // 1. 基础手动缓存
        Cache<String, String> cache = Caffeine.newBuilder()
                .maximumSize(1000)                // 最大缓存条数，LRU自动淘汰冷门数据
                .expireAfterWrite(5, TimeUnit.MINUTES) // 写入后5分钟过期
                .expireAfterAccess(2, TimeUnit.MINUTES)// 2分钟未访问则过期
                .removalListener((key, val, cause) -> {
                    System.out.println("缓存失效 key:" + key + " 原因:" + cause);
                })
                .build();

        // 读写
        cache.put("dict:area:100", "北京市");
        String val = cache.getIfPresent("dict:area:100");
        System.out.println(val);
        cache.invalidate("dict:area:100"); // 删除指定key
        cache.cleanUp(); // 主动清理过期缓存

        // 2. LoadingCache：自动加载数据源（无缓存时自动查库）
        LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(5, TimeUnit.MINUTES)
                .refreshAfterWrite(1, TimeUnit.MINUTES) // 后台定时刷新
                .build(key -> loadFromDb(key)); // 数据加载函数

        String data = loadingCache.get("dict:area:200");
        System.out.println(data);
    }

    // 模拟数据库查询
    private static String loadFromDb(String key) {
        System.out.println("查询数据库：" + key);
        return key + "-data";
    }
}

SpringBoot 集成 Caffeine + @Cacheable 注解

java 复制代码

@Configuration
@EnableCaching
public class CaffeineConfig {
    @Bean
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .maximumSize(2000)
                .expireAfterWrite(5, TimeUnit.MINUTES));
        return cacheManager;
    }
}







@Service
public class DictService {
    // 存入本地缓存
    @Cacheable(value = "localDictCache", key = "#code")
    public String getDict(String code) {
        // 查数据库逻辑
        System.out.println("真实查询数据库:" + code);
        return "字典值-" + code;
    }

    // 更新时清除缓存
    @CacheEvict(value = "localDictCache", key = "#code")
    public void updateDict(String code) {
        // 更新数据库逻辑
    }
}

3.Guava Cache

java 复制代码

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.LoadingCache;
import com.google.common.cache.CacheLoader;

import java.util.concurrent.TimeUnit;

public class GuavaCacheDemo {
    public static void main(String[] args) {
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(5, TimeUnit.MINUTES)
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String key) {
                        return key + "-guava-data";
                    }
                });
    }
}

本地进程缓存的特质

1.JVM 堆内存缓存，仅当前进程可见，重启 / 部署后数据丢失，集群多实例不共享

2.毫秒 / 微秒级读取，减少 DB/Redis 请求，削峰降延迟

3.不能用于强一致性业务、全局分布式状态

4.务必设置 maximumSize 上限 + TTL 过期策略，防止 OOM 与内存泄漏