redis - 缓存 - 锁

缓存

使用 Redis 作为 Cache(缓存)
基本思路:

  1. 首先查询 Redis。

  2. 如果 Redis 中存在数据,直接返回。

  3. 如果 Redis 中不存在数据,查询 MySQL。

  4. 将 MySQL 查询到的数据保存到 Redis,然后返回。

这种读取方式通常称为 Cache-Aside Pattern(旁路缓存模式)。

举例示意图

image

示例代码

1 基础版

    @Resource
    private UserMapper userMapper;
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 业务逻辑没有写错,对于小厂中厂(QPS《=1000)可以使用,但是大厂不行
     * @param id
     * @return
     */
    public User findUserById(Integer id)
    {
        User user = null;
        String key = CACHE_KEY_USER+id;

        //1 先从redis里面查询,如果有直接返回结果,如果没有再去查询mysql
        user = (User) redisTemplate.opsForValue().get(key);

        if(user == null)
        {
            //2 redis里面无,继续查询mysql
            user = userMapper.selectByPrimaryKey(id);
            if(user == null)
            {
                //3.1 redis+mysql 都无数据
                //具体细化,防止多次穿透。比如现在的业务规定,记录下导致穿透的这个key回写redis
                return user;
            }else{
                //3.2 mysql有,需要将数据写回redis,保证下一次的缓存命中率
                redisTemplate.opsForValue().set(key,user);
            }
        }
        return user;
    }

2 双锁校验

以下为单机版的双锁校验,主要是为了体会其中的思想

public User findUserById2(Integer id)
    {
        User user = null;
        String key = CACHE_KEY_USER+id;

        //1 先从redis里面查询,如果有直接返回结果,如果没有再去查询mysql,
        // 第1次查询redis,加锁前
        user = (User) redisTemplate.opsForValue().get(key);
        if(user == null) {
            //2 
            synchronized (UserService.class){
                //第2次查询redis,加锁后
                user = (User) redisTemplate.opsForValue().get(key);
                //3 二次查redis还是null,可以去查mysql了(mysql默认有数据)
                if (user == null) {
                    //4 查询mysql拿数据(mysql默认有数据)
                    user = userMapper.selectByPrimaryKey(id);
                    if (user == null) {
                        return null;
                    }else{
                        //5 mysql里面有数据的,需要回写redis,完成数据一致性的同步工作
                        redisTemplate.opsForValue().setIfAbsent(key,user,7L,TimeUnit.DAYS);
                    }
                }
            }
        }
        return user;
    }

缓存一致性

缓存很难达到强一致,即redis的数据很难做到跟数据库一样是同步的(即最新的),但是可以保证最终一致。

更新缓存的四种策略:

1.先更新数据库,再更新缓存;

2.先更新缓存,再更新数据库:

3.先删除缓存,再更新数据库

4.先更新数据库,再删除缓存

分布式锁

该分布式锁采用redis实现,参考JUC,如自旋重试、只能删除自己加的锁

示例一

最简单的分布式锁。很简单的场景可以使用。

    public String sale()
    {
        String key = "redisLock";
        //value设置为uuid + 线程ID,以此来识别锁的归属
        String uuidValue = IdUtil.simpleUUID()+":"+Thread.currentThread().getId();
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue);
        //抢不到的线程要继续重试
        if(!flag) {
            //暂停20毫秒,进行递归重试
            try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
            sale();
        }else{
            try {
                //执行业务代码
            }finally {
                //释放锁
                stringRedisTemplate.delete(key);
            }
        }
        return "ok";
    }

该实现具有很多问题,比如,递归重试,在高并发下,很多请求,容易方法爆栈。

lua语法

lua可以使得多条命令具有原子性。

最简单的示例

EVAL "return 'hello'" 0

结果:

"hello"

多命令

原本下面的三条命令分别输入时,不是原子的,但是使用lua脚本的写法,就可以是原子的

set k2 "v2"
expire k2 "30"
get k2

下面的写法就是原子的,里面的return是返回命令的结果,只能返回一条命令的结果。redis.call括号里面是执行redis的读写命令

EVAL "redis.call('set','k2','v2') redis.call('expire','k2','30')
 return redis.call('get','k2')" 0 

如果写成return redis.call('set','k2','v2') redis.call('expire','k2','30') redis.call('get','k2'),就会报错,一下子返回三个结果

可以试下下面的,返回的是ok。因为执行set k3 "v3" ,本来就是返回ok,lua只是原封不动地把结果返回给客户端。

EVAL "return redis.call('set','k3','v3')" 0 

带参数

下面的2表示,后面开始的两个参数k01和k02是对应KEYS[1]和KEYS[2],然后redis会智能地认为,剩余的三个参数,lua1和lua2和lua3,分别对应,ARGV[1]和ARGV[2]和ARGV[3]。

EVAL "redis.call('mset',KEYS[1],ARGV[1],KEYS[2],ARGV[2]) 
return redis.call('set','k10',ARGV[3])" 2 k01 k02 lua1 lua2 lua3

同理,下面的3表示,三个参数

EVAL "redis.call('mset',KEYS[1],ARGV[1],KEYS[2],ARGV[2]) 
return redis.call('set',KEYS[3],ARGV[3])" 3 k01 k02 k03 lua1 lua2 lua3
  • KEYS[]和ARGV[],下标都是从1开始

lua的条件语法

示例一

如果key,k1等于v1,那么就删除,否则返回0

EVAL "if redis.call('get',KEYS[1]) == ARGV[1] 
then return redis. call('del',KEYS[1]) 
else  return 0 end" 1 k1 v1

示例二

EVAL "if KEYS[1] > KEYS[2] 
then return ARGV[1]  elseif KEYS[1] < KEYS[2] 
then   return ARGV[2] 
else   return ARGV[3]  end" 2 3 6 1 2 3

结果:

2

进一步改造锁

  • 为了避免高并发下方法爆栈,应该改为自旋重试。

  • 为了避免某某线程加锁后,意外宕掉,导致锁未释放(删除key),应该设置过期时间。

  • 删除锁时,应该判断是不是自己加的锁。因为可能会出现下面的情况。

    • 某场景(比如下单扣库存),通常执行业务代码的时间为10秒,锁设置过期时间为25秒,现在从第0秒开始算,0秒开始,有A、B、C请求同时进来,A抢到锁,到了第12秒A仍未执行完,锁过期,B获取到了锁,执行代码,到了第15秒,A终于执行完,然后删除锁,瞬间C取得了锁。A删除的锁是B加的锁,这样是不符合代码预期。
  • 删除锁,除了要判断锁是不是自己的,还要让“删除锁”和“判断”这两步是原子的。因为在判断锁时,假设判断是自己的,然后卡住一段时间,锁过期了,B来加锁,又删错锁了。

    • 使用lua保证原子性。

改造后的代码

    public String saleGoods(){
        String key ="goodLock";
        String uuidValue = IdUtil.simpleUUID()+":"+Thread.currentThread().getId();
        while (!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue, 25L, TimeUnit.SECONDS)){
            try{TimeUnit.MILLISECONDS.sleep(20);}catch (InterruptedException e){e.printStackTrace();}
        }
        try{
            //执行业务代码...
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            String unlockScrip="if redis.call('get',KEYS[1]) == ARGV[1] " +
                    "then return redis.call('delete',KEYS[1]) " +
                    "else return 0 end";
            stringRedisTemplate.execute(new DefaultRedisScript(unlockScrip, Boolean.class), Arrays.asList(key),uuidValue);
        }
        return "OK";
    }

上述代码在一般的场景、简单的场景下可以使用。
但是如果追求比较好通用性,需要考虑可重入和自动续期

重入和自动续期

所谓的重入,可以复习JUC里的可重入的概念。

自动续期,指的是在获取锁后,启动一个线程,在一定时间内,未过期前,自动将锁续期

RedLock

posted @ 2026-10-21 21:16  dvdhellohaha  阅读(4)  评论(0)    收藏  举报