缓存击穿解决方案（互斥锁+双端检查机制）的优化

最新推荐文章于 2024-07-25 20:08:00 发布

想象之中丶

最新推荐文章于 2024-07-25 20:08:00 发布

阅读量78

点赞数 1

分类专栏： SpringBoot 文章标签：缓存

本文链接：https://blog.csdn.net/weixin_58267543/article/details/132557540

版权

SpringBoot 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

原`互斥锁+双端检查机制`方案

原方案中，synchronized的锁对象为UserServiceImpl.class（即当前接口实现类）
该方案中，不论查询的key是什么，synchronized锁对象都为UserServiceImpl.class

public UserInfo getUserByIdFirstRedis(Integer id) {
        UserInfo userInfo;
        String key = "user_" + id;
        userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
        if (null == userInfo || userInfo.getId() == 0) {
            // 锁对象为 UserServiceImpl.class（即当前接口实现类）
            synchronized (UserServiceImpl.class) {
                // 再次检查，防止线程获取到锁后，redis中已经存在数据
                userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
                if (null == userInfo || userInfo.getId() == 0) {
                    System.out.println(Thread.currentThread().getName() + " =》实际请求MySQL");
                    userInfo = userDao.getById(id);
                    redisTemplate.opsForValue().set(key, userInfo);
                }
            }
        }
        return userInfo;
    }

`互斥锁+双端检查机制`方案的`优化`点

优化点：降低synchronized的锁对象，即减小锁的粒度
原方案中，synchronized锁对象是UserServiceImpl.class，故不论哪个key进来，都需要排队等待锁
优化后，synchronized锁对象优化为缓存key，相同key排队等待锁，不同key可以并发请求更新redis数据，提高了并发度
难点：如何让每个请求进来，同样的变量参数，能够获取到同一个key锁对象？
- 方案：利用字符串常量池，将参数变量生成的key放到字符串常量池中，后续只要key相同，都会返回常量池中的同一个String对象

public UserInfo getUserByIdFirstRedis(Integer id) {
        UserInfo userInfo;
        // 把key放到字符串常量池中，这样并发线程进入后，可以获取同一个字符串常量对象
        String key = ("user_" + id).intern();
        userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
        if (null == userInfo || userInfo.getId() == 0) {
            // 这里是互斥锁，让每个key的查询，只有一个线程进入并打到MySQL上
            // 由于key是在字符串常量池中，故同一个key获取的是字符串常量池对象
            synchronized (key) {
                // 再次检查，防止线程获取到锁后，redis中已经存在数据
                userInfo = (UserInfo) redisTemplate.opsForValue().get(key);
                if (null == userInfo || userInfo.getId() == 0) {
                    System.out.println(Thread.currentThread().getName() + " =》实际请求MySQL");
                    userInfo = userDao.getById(id);
                    redisTemplate.opsForValue().set(key, userInfo);
                }
            }
        }
        return userInfo;
    }

测试

2个key，同时发出1000个线程请求，对比两个方案的执行时间
同时检测优化后的方案是否会出现锁不住情况

public void getUserByIdFirstRedis() {
		// 利用CountDownLatch等待2个key执行完成
        CountDownLatch count1 = new CountDownLatch(1000);
        CountDownLatch count2 = new CountDownLatch(1000);
        long s = System.currentTimeMillis();

		// key = 1
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                userService.getUserByIdFirstRedis(1);
                count1.countDown();
            }, "t1::" + i).start();
        }
        // key = 2
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                userService.getUserByIdFirstRedis(2);
                count2.countDown();
            }, "t2=》" + i).start();
        }
        try {
            count1.await();
            count2.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("总耗时 =》" + (System.currentTimeMillis() - s));
    }