【Java】解决线程本地变量导致的缓存问题

public class ThreadLocalCacheExample {
 
    // 假设这是一个用于计算复杂数据的服务
    private static ComplexComputingService complexService = new ComplexComputingService();
 
    // 定义ThreadLocal存储缓存数据
    private static final ThreadLocal<Cache> cache = new ThreadLocal<Cache>() {
        @Override
        protected Cache initialValue() {
            return new Cache();
        }
    };
 
    public Data getCachedData(String key) {
        // 尝试从缓存获取数据
        Data data = cache.get().get(key);
        if (data == null) {
            // 缓存中没有，则计算并存储到缓存中
            data = complexService.computeData(key);
            cache.get().put(key, data);
        }
        return data;
    }
 
    public static void main(String[] args) {
        // 示例代码，模拟多线程环境下的缓存使用
        ThreadLocalCacheExample cacheExample = new ThreadLocalCacheExample();
        for (int i = 0; i < 100; i++) {
            final int index = i;
            new Thread(() -> {
                Data data = cacheExample.getCachedData("key-" + index);
                // 处理data...
            }).start();
        }
    }
 
    // 缓存数据的简单结构
    private static class Cache {
        private Map<String, Data> dataMap = new HashMap<>();
 
        public Data get(String key) {
            return dataMap.get(key);
        }
 
        public void put(String key, Data data) {
            dataMap.put(key, data);
        }
    }
 
    // 假设的复杂数据计算服务
    private static class ComplexComputingService {
        public Data computeData(String key) {
            // 模拟复杂计算
            return new Data(key, "result-" + key);
        }
    }
 
    // 假设的数据类型
    private static class Data {
        private String key;
        private String value;
 
        public Data(String key, String value) {
            this.key = key;
            this.value = value;
        }
 
        // getters and setters...
    }
}

这个示例代码展示了如何使用ThreadLocal来避免多线程环境下的数据竞争问题，并提供了一个简单的缓存机制。每个线程都会有自己的Cache实例，从而避免了不同线程之间共享数据时可能发生的状态不一致问题。