分布式锁+Redis，解决集群业务数据缓存

最新推荐文章于 2021-05-11 09:44:21 发布

咩嘢<-ヘ->

最新推荐文章于 2021-05-11 09:44:21 发布

阅读量664

点赞数

分类专栏： Java Redis 文章标签：分布式 redis java

本文链接：https://blog.csdn.net/weixin_44378311/article/details/106676954

版权

Java 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

Redis

1 篇文章 0 订阅

订阅专栏

文章目录

分布式锁
分布式锁 + AOP实现缓存

分布式锁

1. 分布式锁实现

随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力。为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！
分布式锁主流的实现方案：

基于数据库实现分布式锁
基于缓存（Redis等）
基于Zookeeper
每一种分布式锁解决方案都有各自的优缺点：
性能：redis最高
可靠性：zookeeper最高
菜鸡的我就是基于redis实现分布式锁来进行学习的，之后遇到相关问题再更新文章。

2. 使用redis实现分布式锁

redis:命令
set sku:1:info “OK” NX PX 10000
EX second ：设置键的过期时间为 second 秒。 SET key value EX second 效果等同于 SETEX key second value 。
PX millisecond ：设置键的过期时间为 millisecond 毫秒。 SET key value PX millisecond 效果等同于 PSETEX key millisecond value 。
NX ：只在键不存在时，才对键进行设置操作。 SET key value NX 效果等同于 SETNX key value 。
XX ：只在键已经存在时，才对键进行设置操作。

在这里插入图片描述

多个客户端同时获取锁（setnx）
获取成功，执行业务逻辑，执行完成释放锁（del）
其他客户端等待重试

学习优化

问题：setnx刚好获取到锁，业务逻辑出现异常，导致锁无法释放
解决：设置锁过期时间，自动释放锁。
问题：业务操作时间可能会大于锁失效时间，这时候本线程可能会删除别的线程的锁
解决：setnx获取锁时，设置一个指定的唯一值（例如：uuid）；释放前获取这个值，判断是否自己的锁
问题：操作缺乏原子性
解决：LUA脚本保证删除的原子性

总结

为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：

互斥性。在任意时刻，只有一个客户端能持有锁。
不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。
加锁和解锁必须具有原子性。

redis集群状态下的问题：

客户端A从master获取到锁
在master将锁同步到slave之前，master宕掉了。
slave节点被晋级为master节点
客户端B取得了同一个资源被客户端A已经获取到的另外一个锁。
安全失效！
解决方案：
Redlock实现
antirez提出的redlock算法大概是这样的：

在Redis的分布式环境中，我们假设有N个Redis master。这些节点完全互相独立，不存在主从复制或者其他集群协调机制。我们确保将在N个实例上使用与在Redis单实例下相同方法获取和释放锁。现在我们假设有5个Redis master节点，同时我们需要在5台服务器上面运行这些Redis实例，这样保证他们不会同时都宕掉。

为了取到锁，客户端应该执行以下操作:

获取当前Unix时间，以毫秒为单位。

依次尝试从5个实例，使用相同的key和具有唯一性的value（例如UUID）获取锁。当向Redis请求获取锁时，客户端应该设置一个网络连接和响应超时时间，这个超时时间应该小于锁的失效时间。例如你的锁自动失效时间为10秒，则超时时间应该在5-50毫秒之间。这样可以避免服务器端Redis已经挂掉的情况下，客户端还在死死地等待响应结果。如果服务器端没有在规定时间内响应，客户端应该尽快尝试去另外一个Redis实例请求获取锁。

客户端使用当前时间减去开始获取锁时间（步骤1记录的时间）就得到获取锁使用的时间。当且仅当从大多数（N/2+1，这里是3个节点）的Redis节点都取到锁，并且使用的时间小于锁失效时间时，锁才算获取成功。

如果取到了锁，key的真正有效时间等于有效时间减去获取锁所使用的时间（步骤3计算的结果）。

如果因为某些原因，获取锁失败（没有在至少N/2+1个Redis实例取到锁或者取锁时间已经超过了有效时间），客户端应该在所有的Redis实例上进行解锁（即便某些Redis实例根本就没有加锁成功，防止某些节点获取到锁但是客户端没有得到响应而导致接下来的一段时间不能被重新获取锁）。
摘抄自（Redlock实现）

使用redisson解决分布式锁

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。
在这里插入图片描述
官方文档地址：https://github.com/redisson/redisson/wiki
连接文档：https://github.com/redisson/redisson

1. 导入依赖 service-util


<!-- redisson -->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.11.2</version>
</dependency>

2. 配置redisson


@Data
@Configuration
@ConfigurationProperties("spring.redis")
public class RedissonConfig {

private String host;

private String password;

private String port;

private int timeout = 3000;
private static String ADDRESS_PREFIX = "redis://";

/**
     * 自动装配
     */
@Bean
RedissonClient redissonSingle() {
        Config config = new Config();

if(StringUtils.isEmpty(host)){
throw new RuntimeException("host is  empty");
        }
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(ADDRESS_PREFIX + this.host + ":"+ port)
                .setTimeout(this.timeout);
if(!StringUtils.isEmpty(this.password)) {
            serverConfig.setPassword(this.password);
        }
return Redisson.create(config);
    }
}

可重入锁（Reentrant Lock）

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。
大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。
另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

@Autowired
private RedissonClient redisson;
...
RLock lock = redisson.getLock("anyLock");
// 最常使用
lock.lock();
// 加锁以后10秒钟自动解锁
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       lock.unlock();
   }
}
...

测试代码

public String testLockRedisson(){
    RLock lock = redissonClient.getLock("lock");
    try {
    //三把锁，选一
        lock.lock();// 永久
        lock.lock(10, TimeUnit.SECONDS);// 10秒后过期
        try {
            boolean b = lock.tryLock(100, 10, TimeUnit.SECONDS);
            if (b) {
                // 相当于redis的setnx成功
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }finally {
        lock.unlock();// 解锁
    }
    return null;
}

测试代码

	@Autowired
    RedisTemplate redisTemplate;

/***
     * 使用aop缓存注解前
     * @param skuId
     * @return
     */
//    @Override
    public SkuInfo getSkuInfoBak(Long skuId) {
        //存储数据的key
        String skuRedisKey = 前缀+skuId+后缀;
        //分布式锁的lock
        String skuRedisLock = 前缀+skuId+后缀;
        SkuInfo skuInfo = null;

        //查询缓存
        String skuInfoStr = (String) redisTemplate.opsForValue().get(skuRedisKey);
        //判断是否为空，不为空设置返回数据为从缓存中取出的
        if (StringUtils.isNotBlank(skuInfoStr)){
            skuInfo = JSON.parseObject(skuInfoStr,SkuInfo.class);

        }else {//skuInfo为空
            //用来确定是本线程要删除的分布式锁的UUID
            String uuid = UUID.randomUUID().toString();
            //分布式锁的key，sku:skuId:lock
            Boolean OK = redisTemplate.opsForValue().setIfAbsent(skuRedisLock, uuid, RedisConst.SKULOCK_EXPIRE_PX1, TimeUnit.SECONDS);
            //获取到锁
            if (OK){
            //执行查询db操作
                skuInfo = getSkuInfoDB(skuId);
                //查询不存在的数据时，为防止redis缓存穿透，将空值也放入到redis中，并设置一个失效时间
                if (skuInfo==null){
                    skuInfo = new SkuInfo();
                    redisTemplate.opsForValue().set(skuRedisKey, JSON.toJSONString(skuInfo),60*60,TimeUnit.SECONDS);
                    return skuInfo;
                }
                //查询到数据，放入redis
                redisTemplate.opsForValue().set(skuRedisKey, JSON.toJSONString(skuInfo));//缓存中的商品详情key

                //使用lua脚本删除分布式锁 // lua，在get到key后，根据key的具体值删除key
                DefaultRedisScript<Long> luaScript = new DefaultRedisScript<>();
                //设置返回值类型
                luaScript.setResultType(Long.class);
                luaScript.setScriptText("if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end");
                redisTemplate.execute(luaScript, Arrays.asList(skuRedisLock), uuid);
                return skuInfo;

            }else {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return getSkuInfo(skuId);
            }
        }

        return skuInfo;
    }

分布式锁 + AOP实现缓存

随着业务中缓存及分布式锁的加入，业务代码变的复杂起来，除了需要考虑业务逻辑本身，还要考虑缓存及分布式锁的问题，增加了工作量及开发难度。而缓存的玩法套路特别类似于事务，而声明式事务就是用了aop的思想实现的。在这里插入图片描述

以 @Transactional 注解为植入点的切点，这样才能知道@Transactional注解标注的方法需要被代理。
@Transactional注解的切面逻辑类似于@Around

模拟事务，缓存可以这样实现：

自定义缓存注解@GmallCache（类似于事务@Transactional）
编写切面类，使用环绕通知实现缓存的逻辑封装

1. 定义一个注解

import java.lang.annotation.*;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface GmallCache {

/**
* 缓存key的前缀
* @return
*/
String prefix() default "cache";
}

2. 定义一个切面类加上注解

@Component//把切面类加入到IOC容器中
@Aspect//使之成为切面类
public class GmallCacheAspect {

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private RedisTemplate redisTemplate;

    //定义需要匹配的切点表达式，使用了注解GmallCache的方法为切入点
    @Around("@annotation(com.atguigu.gmall.common.cache.GmallCache)")
    public Object AopCache(ProceedingJoinPoint point){
        //声明一个object对象，作为返回结果
        Object result = null;
        //获得连接点参数
        Object[] args = point.getArgs();

        //通过反射获得原始方法信息
        MethodSignature signature = (MethodSignature) point.getSignature();
        //返回值类型
        Class returnType = signature.getReturnType();
        //注解信息
        GmallCache gmallCache = signature.getMethod().getAnnotation(GmallCache.class);

        //获取注解信息，作为前缀
        String prefix = gmallCache.prefix();

        //根据注解信息拼接缓存key
        String key = prefix+ Arrays.asList(args);
        String keyInfo = key+后缀;

        //缓存代码执行
        result = cacheHit(returnType,keyInfo);

        //表示缓存不为空，则直接返回结果
        if (result!=null){
            return result;
        }

        //缓存为空，从数据库中查询
        //使用redisson获得分布式锁
        RLock lock = redissonClient.getLock(key + 随意后缀);

        //执行连接点方法，查询db
        try {
        // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
            boolean b = lock.tryLock(100, 10, TimeUnit.SECONDS);
            //获得锁
            if (b){
                //执行连接点方法，查询db
                result = point.proceed(args);
                //如果查询数据库查询不到数据，将空对象放入缓存中，防止缓存穿透
                if (result==null){
                    redisTemplate.opsForValue().setIfAbsent(keyInfo, JSON.toJSONString(new Object()), 60*60, TimeUnit.SECONDS);
                    return result;
                }else {
                    //查询数据库获得数据不为空，同步到redis缓存中然后返回结果
                    redisTemplate.opsForValue().set(keyInfo, JSON.toJSONString(result));

                    //返回结果
                    return result;
                }

            }else {
                // 如果没有拿到分布式锁，那么说明已经有人查数据库了，当前执行的线程直接取缓存里面拿其他线程已经存入的数据就行了
                Thread.sleep(1000);
                //看一些资料好像算自旋锁
                cacheHit(returnType,keyInfo);
            }
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }finally {
            lock.unlock();
        }

        return result;//返回原来的方法需要的结果
    }

    /***
     * 查询缓存中的key
     * @param returnType
     * @param key
     * @return
     */
    private Object cacheHit(Class returnType, String key) {
        Object resulet = null;
        String cache = (String) redisTemplate.opsForValue().get(key);
        if (StringUtils.isNotBlank(cache)){
            resulet = JSON.parseObject(cache,returnType);
        }

        return resulet;
    }
}

3. 将需要使用缓存的方法加上缓存注解

redis无缓存的时候执行，

@GmallCache()//可以自己加set方法，设置前缀
public SkuInfo getSkuInfo(Long skuId) {
//查询数据库方法
return getSkuInfoDB(skuId);
}

咩嘢<-ヘ->

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
分布式锁+Redis，解决集群业务数据缓存

文章目录分布式锁1. 分布式锁实现2. 使用redis实现分布式锁学习优化总结redis集群状态下的问题：使用redisson解决分布式锁1. 导入依赖 service-util2. 配置redisson可重入锁（Reentrant Lock）测试代码分布式锁 + AOP实现缓存1. 定义一个注解2. 定义一个切面类加上注解3. 将需要使用缓存的方法加上缓存注解分布式锁1. 分布式锁实现随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，
复制链接

扫一扫