Redis：互斥锁实现

待我称王封你为后i 2024-03-24 08:33 10阅读 0赞

import cn.hutool.core.util.BooleanUtil;
    import cn.hutool.core.util.StrUtil;
    import cn.hutool.json.JSONUtil;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import java.util.concurrent.TimeUnit;
    import java.util.function.Function;
    
    @Component
    public class CacheClient {
    
        private final StringRedisTemplate stringRedisTemplate;
    
        public CacheClient(StringRedisTemplate stringRedisTemplate) {
            this.stringRedisTemplate = stringRedisTemplate;
        }
    
        public void set(String key, Object value, Long time, TimeUnit unit) {
    
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
        }
    
        public boolean tryLock(String key) {
            Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
            return BooleanUtil.isTrue(flag);
        }
    
        public void unlock(String key) {
            stringRedisTemplate.delete(key);
        }
    
    
        public <R, ID> R queryWithMutex(
                String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
    
            String key = keyPrefix + id;
            // 1.从redis查询数据缓存
            String json = stringRedisTemplate.opsForValue().get(key);
            // 2.判断是否存在
            if (StrUtil.isNotBlank(json)) {
                // 3.存在，直接返回
                return JSONUtil.toBean(json, type);
            }
    
            // 判断命中的是否是空值
            if (json != null) {
                // 返回一个错误信息
                return null;
            }
    
            // 4.实现缓存重建
            // 4.1.获取互斥锁
            String lockKey = LOCK_SHOP_KEY + id;
            R r = null;
    
            try {
    
                boolean isLock = tryLock(lockKey);
    
                // 4.2.判断是否获取成功
                if (!isLock) {
                    // 4.3.获取锁失败，休眠并重试
                    Thread.sleep(50);
                    return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
                }
    
                // 4.4.获取锁成功，根据id查询数据库
                r = dbFallback.apply(id);
    
                // 5.不存在，返回错误
                if (r == null) {
                    // 将空值写入redis
                    stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                    // 返回错误信息
                    return null;
                }
    
                // 6.存在，写入redis
                this.set(key, r, time, unit);
            } catch (InterruptedException e) {
    
                throw new RuntimeException(e);
            }finally {
    
                // 7.释放锁
                unlock(lockKey);
            }
    
            // 8.返回
            return r;
        }
    }

import cn.hutool.core.util.StrUtil;
    
    /**
     *  服务实现类
     */
    @Service
    public class DemoServiceImpl extends ServiceImpl<DemoMapper, Demo> implements IDemoService {
    
        @Resource
        private CacheClient cacheClient;
    
        @Override
        public Result queryById(Long id) {
    
    
            // 互斥锁解决缓存击穿
            Demo demo = cacheClient
                .queryWithMutex(CACHE_SHOP_KEY, id, Demo.class, this::getById, CACHE_DEMO_TTL, TimeUnit.MINUTES);
    
            if (demo== null) {
                return Result.fail("demo不存在！");
            }
    
            // 返回
            return Result.ok(demo);
        }
    
    }