万字详解本地锁到分布式锁的演进、Redis实现以及扩展 Redlock 红锁

最新推荐文章于 2024-04-07 13:10:34 发布

搬山道猿

最新推荐文章于 2024-04-07 13:10:34 发布

阅读量310

点赞数

文章标签： redis 分布式缓存

本文链接：https://blog.csdn.net/2301_76607156/article/details/130128592

版权

本文详细介绍了从本地锁到分布式锁的演进过程，探讨了本地锁存在的问题及解决办法。在分布式锁实现中，讲解了Redis的setnx命令、死锁解决、lua脚本原子操作、Redisson的使用以及锁续期。文章还提到了分布式事务锁的挑战，并引出了Redis的红锁（Redlock）算法，分析了红锁的原理、异步性、失败重试策略、释放锁机制及其补充。文章最后提醒读者注意代码中递归调用的潜在问题，建议改用循环重试并限制次数以避免无限递归导致的崩溃。

摘要由CSDN通过智能技术生成

聊到分布式锁，就不得不先聊到本地锁，如果没有从本地锁到分布式锁这个演进过程或者说是推导过程，我觉得是不合适的，甚至是不完整的。

程序的发展是一步一步递进，知道它是解决什么样的问题，才能更好的理解和学习。

文章大纲：

本文字数约为1w字左右，建议可以腾出一点点空闲时间来阅读，都是我的存稿~ 哈哈，寻思着再不发，这个月都得过完了。

关于代码：

后期在检查时，发现案例中的代码是有点不太合适的，应当将所有案例中的递归调用方法改为循环重试，并限制重试次数，而非一直递归调用。切记切记切记👨‍💻。

一、本地锁

1.1、本地锁的使用

本地锁主要是针对单体服务而言的，锁的都是单体应用内的进程。

像之前在单机情况下出现的读写并发情况。因为并发情况下网络出现问题或是出现其他卡顿问题，导致执行顺序发生变化，从而产生了数据不一致性。如下图：

解决并发最快的方式就是加锁吗，我们也就给它来把锁吧，Java中的锁是有蛮多的，我这里不过多讨论啦（synchronized、JUC）等等。

我案例中所使用的是 JUC 包下的读写锁ReentrantReadWriteLock ，毕竟不能让锁直接限制了Redis 的发挥~，读写锁是读并发，写独占的模式。

增加读写锁之后的流程图如下：

（图片说明：加上锁之后的流程）

案例代码如下：

/**
 * @description: 单机redis下的操作
 * @author: Ning Zaichun
 * @date: 2022年09月06日 23:20
 */
@Slf4j
@Service
public class RedisCacheServiceImpl implements IRedisCacheService {


    @Autowired
    private MenuMapper menuMapper;

    @Autowired
    StringRedisTemplate redisTemplate;

    private static final String REDIS_MENU_CACHE_KEY = "menu:list";

    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();


    @Override
    public List<MenuEntity> getList() {
        //1、从缓存中获取
        String menuJson = redisTemplate.opsForValue().get(REDIS_MENU_CACHE_KEY);
        if (!StringUtils.isEmpty(menuJson)) {
            System.out.println("缓存中有，直接从缓存中获取");
            //2、缓存不为空直接返回
            List<MenuEntity> menuEntityList = JSON.parseObject(menuJson, new TypeReference<List<MenuEntity>>() {
            });
            return menuEntityList;
        }
        //3、查询数据库
        //不加锁情况下
        // List<MenuEntity> noLockList = getMenuJsonFormDb();
        // 加锁情况下
        List<MenuEntity> menuEntityList = getMenuJsonFormDbWithReentrantReadWriteLock();
        return menuEntityList;
    }

    public List<MenuEntity> getMenuJsonFormDb() {
        System.out.println("缓存中没有，重新从数据中查询~==>");
        //缓存为空，查询数据库，重新构建缓存
        List<MenuEntity> result = menuMapper.selectList(new QueryWrapper<MenuEntity>());
        //4、将查询的结果，重新放入缓存中
        redisTemplate.opsForValue().set(REDIS_MENU_CACHE_KEY, JSON.toJSONString(result));
        return result;
    }

    public List<MenuEntity> getMenuJsonFormDbWithReentrantReadWriteLock() {
        List<MenuEntity> result = null;
        System.out.println("缓存中没有，加锁，重新从数据中查询~==>");
        // synchronized 是同步锁，所以当多个线程同时执行到这里时，会阻塞式等待
        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        readLock.lock();
        try {
            String menuJson = redisTemplate.opsForValue().get(REDIS_MENU_CACHE_KEY);
            //加锁成功... 再次判断缓存是否为空
            if (!StringUtils.isEmpty(menuJson)) {
                System.out.println("缓存中，直接从缓存中获取");
                //2、缓存不为空直接返回
                List<MenuEntity> menuEntityList = JSON.parseObject(menuJson, new TypeReference<List<MenuEntity>>() {
                });
                return menuEntityList;
            }
            //缓存为空，查询数据库，重新构建缓存
            result = menuMapper.selectList(new QueryWrapper<MenuEntity>());
            //4、将查询的结果，重新放入缓存中
            redisTemplate.opsForValue().set(REDIS_MENU_CACHE_KEY, JSON.toJSONString(result));
            return result;
        } finally {
            readLock.unlock();
        }
    }


    @Override
    public Boolean updateMenuById(MenuEntity menu) {
        //return updateMenuByIdNoWithLock(menu);
        return updateMenuByIdWithReentrantReadWriteLock(menu);
    }


    public Boolean updateMenuByIdNoWithLock(MenuEntity menu) {
        // 1、删除缓存
        redisTemplate.delete(REDIS_MENU_CACHE_KEY);
        System.out.println("清空单机Redis缓存");
        // 2、更新数据库
        return menuMapper.updateById(menu) > 0;
    }

    public Boolean updateMenuByIdWithReentrantReadWriteLock(MenuEntity menu) {
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
        writeLock.lock();
        try {
            // 1、删除缓存
            System.out.println("清除缓存");
            redisTemplate.delete(REDIS_MENU_CACHE_KEY);
            // 2、更新数据库
            return menuMapper.updateById(menu) > 0;
        }finally {
            writeLock.unlock();
        }
    }
}
复制代码

具体还需大家去了解~

我这里加的 JUC 下的读写锁，原本我想的是弄的JUC的锁