ThreadLocal也可以用作缓存

ThreadLocal是什么？

ThreadLocal是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个线程依赖不通的变量值完成操作的场景。
对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

Spring请求如何保证线程安全？

Spring的Controller默认是Singleton的，这意味着每个请求过来，系统都会用原有的Instance去处理，这样导致了两个结果:一是我们不用每次创建Controller，二是减少了对象创建和垃圾收集的时间;由于只有一个Controller的instance，当多个线程调用它的时候，它里面的instance变量就不是线程安全的了，会发生窜数据的问题。当然大多数情况下，我们根本不需要考虑线程安全的问题，比如dao,service等，除非在bean中声明了实例变量。

如果控制器是使用单例形式，且Controller中有一个私有的变量a,所有请求到同一个Controller时，使用的a变量是共用的，即若是某个请求中修改了这个变量a，则，在别的请求中能够读到这个修改的内容。Spring使用 ThreadLocal 进行处理，ThreadLocal 是线程本地变量，每个线程拥有变量的一个独立副本，所以各个线程之间互不影响，保证了线程安全。

解决线程安全的方法有以下几个：
1、在Controller中使用ThreadLocal变量
2、在spring配置文件Controller中声明 scope="prototype"，每次都创建新的controller

案例分析：

除了解决线程安全问题之外，ThreadLocal还能做什么呢？
场景：如果在一次用户请求中，多次发生查询某一行成绩记录的动作，反复查询相同的结果会对DB造成压力，这里可以将请求保存在ThreadLocal里面，其他查询直接从ThreadLocal中取值即可。

查询服务

代码实现

根据学号和年级查询成绩信息

public interface ScoreRepo extends JpaRepository {
    Optional findByUidAndAndClassId(String uid, String classId);
}

ContextHolder类用于保存缓存信息

public class ContextHolder {
    private static ThreadLocal threadLocal = new ThreadLocal<>();

    /**
     * 获取线程上下文
     * @return
     */
    public static ThreadLocal getThreadLocal() {
        return threadLocal;
    }

    /**
     * 设置操作上下文
     * @param contextInfo
     */
    public static void setThreadLocal(ContextInfo contextInfo) {
        threadLocal.set(contextInfo);
    }

    /**
     * 清理线程上下文
     */
    public static void clear(){
        try{
            if(null!=threadLocal.get()){
                threadLocal.remove();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadLocal.set(null);
        }
    }

    public static Optional getScoreVOResult(String uid, String classId){
        ContextInfo context = threadLocal.get();
        if(context == null){
            return null;
        }
        return context.getScoreVOResult().get(Pair.of(uid, classId));
    }

    public static void setScoreVOResult(String uid, String classId, Optional score){
        ContextInfo context = threadLocal.get();
        if(context == null){
            context = new ContextInfo();
            threadLocal.set(context);
        }
        context.getScoreVOResult().put(Pair.of(uid, classId), score);
    }
}

查询时如果缓存中有值直接取出，如果没有先从DB查询再放入缓存

@Service
public class ThreadLocalCacheService {

   @Autowired
   private ScoreRepo scoreRepo;

   public Optional queryScore(String uid, String classId) {
       Optional score = ContextHolder.getScoreVOResult(uid, classId);
       if (null != score) {
           return score;
       }
       score = scoreRepo.findByUidAndAndClassId(uid, classId);
       if (null != score && score.isPresent()) {
           ContextHolder.setScoreVOResult(uid, classId, score);
       }
       return score;
   }
}

这里为了模拟重复查询，使用for循环对DB重复查询10次

@Override
 public ScoreVO queryScoreOne(String uid, String classId) {
     Optional score = cacheService.queryScore(uid, classId);
     // 查询10次socre
     for (int i = 0; i < 10; i++) {
         score = cacheService.queryScore(uid, classId);
     }
     if (score.isPresent()) {
         return ScoreVO.builder().uid(score.get().getUid()).className(score.get().getClassName()).score(score.get().getScore()).build();
     } else {
         return null;
     }
 }

效果测试

查询结果测试

@Test
   public void testQueryScore(){
       String uid = "12345";
       String classId = "1";
       Optional score1 = cacheService.queryScore(uid, classId);
       Optional score2 = cacheService.queryScore(uid, classId);
       Assert.assertEquals(score1, score2);
   }

只出现一条查询语句，并且对象相等

查询测试

使用PostMan测试第一条查询，只出现一次DB查询
http://localhost:8082/score/query1/12345/1
postman测试查询1

postman测试查询1

查询10次，后续都是从缓存中获取

查询10次，后续都是从缓存中获取

DB查询结果

DB查询结果

再次发起一次查询，又出现一条查询记录，说明ThreadLocal只缓存当前线程的请求，对新的请求失效，可以采用其他策略。
二次查询结果：

二次查询结果

源码分析

源码参考