Redis分布式锁

最新推荐文章于 2023-09-20 19:30:40 发布
最新推荐文章于 2023-09-20 19:30:40 发布
阅读量140 收藏 1
点赞数 1
分类专栏： SpringBoot 分布式 Redis 文章标签： redis java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_32232683/article/details/104934318
版权
SpringBoot 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
分布式
2 篇文章 0 订阅
订阅专栏
Redis
2 篇文章 0 订阅
订阅专栏

介绍

单机环境下，操作系统能够在进程或线程之间通过本地的锁来控制并发程序的行为。而在分布式架构或者集群环境下，基于本地单机的锁无法控制分布式系统中分开部署客户端的并发行为，此时分布式锁就应运而生了。

特性（本例支持特性）：

  1. 多进程可见性（支持）：多个客户端可感知

  2. 互斥性（支持）：作为锁，需要保证任何时刻只能有一个客户端(用户)持有锁

  3. 可重入（不支持）： 同一个客户端在获得锁后，可以再次进行加锁。重入可用hash结构实现，每次重入value+1，思路差不多

  4. 高可用（支持）：获取锁和释放锁的效率较高，不会出现单点故障

  5. 自旋（支持）：当客户端加锁失败时，能够提供一种机制让客户端自动重试

使用场景

  • 秒杀场景，要求并发量很高，两个人人同时下单那么同一件商品只能被一个用户抢到,类似的需求都会用到分布式锁
    秒杀

  • 定时任务（项目集群被坑过，没经验）

lua脚本

lua脚本，保证加锁和解锁的原子性

// 加锁
if redis.call('setNx',KEYS[1],ARGV[1]) then 
    if redis.call('get',KEYS[1])==ARGV[1] then 
        return redis.call('pexpire',KEYS[1],ARGV[2])
    else 
        return 0 
    end 
end


// 解锁
if redis.call('get', KEYS[1]) == ARGV[1] then 
    return redis.call('del', KEYS[1]) 
else 
    return 0 
end


/**
 * redis分布式锁，不支持重入和redis集群
 */
public class RedisLock implements Lock {

    private StringRedisTemplate redisTemplate;
    private String lockKey;
    private String lockValue;
    private long expireTime = 30000L;  //默认锁过期时间 30s
    private long outTime = 5000L;  //默认获取锁超时时间 5s
    private long retyTime = 500L; //重试时间0.5s,(单位毫秒)
    private static final String LOCK_SUCCESS = "1";
    private static final String TRY_LOCK_SCRIPT = "if redis.call('setNx',KEYS[1],ARGV[1]) then if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('pexpire',KEYS[1],ARGV[2]) else return 0 end end";
    private static final String RELEASE_LOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    
    /**
     * @param lockKey       key
     * @param redisTemplate
     */
    public RedisLock(String lockKey, StringRedisTemplate redisTemplate) {
        this.lockKey = lockKey;
        this.redisTemplate = redisTemplate;
    }
    
    /**
     * @param lockKey       key
     * @param expireTime   锁过期时间
     * @param redisTemplate
     */
    public RedisLock(String lockKey, long expireTime, StringRedisTemplate redisTemplate) {
    	this(lockKey,redisTemplate);
        this.expireTime = expireTime;
    }
    
    /**
     * 
     * @param lockKey key
     * @param expireTime 过期时间
     * @param outTime 请求超时时间
     * @param retyTime 重试时间间隔
     * @param redisTemplate
     */
    public RedisLock(String lockKey, long expireTime, long outTime, long retyTime, StringRedisTemplate redisTemplate) {
    	this(lockKey,expireTime,redisTemplate);
    	this.outTime = outTime;
        this.retyTime = retyTime;

    }

    @SuppressWarnings("unchecked")
	@Override
    public boolean lock() {
        // 加锁客户端唯一标识,UUID。
        this.lockValue = IdUtil.getSnowflake(1L, 1L).nextIdStr();
        Object result = redisTemplate.execute(RedisScript.of(TRY_LOCK_SCRIPT, Long.class), Collections.singletonList(lockKey), lockValue, String.valueOf(this.expireTime));
        return LOCK_SUCCESS.equals(String.valueOf(result));
    }

    @Override
    public boolean tryLock(long tryLockTime, TimeUnit timeUnit) {
        // 是否死循环获取锁
        boolean forever = tryLockTime < 0;
        // 开始获取锁的时间
        final long startTime = System.currentTimeMillis();
        tryLockTime = (tryLockTime < 0) ? 0:tryLockTime;
        // 统一转为毫秒，阻塞毫秒数
        final Long tryTime = (timeUnit != null) ? timeUnit.toMillis(tryLockTime) : 0;
        // 如果没有加锁成功，循环尝试获取锁
        while (true) {
            // 获取成功 退出
            if (lock()) {
            	return Boolean.TRUE;
            }
            // 如果不是必须获取到锁，超过了获取锁的最长时间，退出
            if (!forever && System.currentTimeMillis() - startTime - this.retyTime > tryTime) {
            	return Boolean.FALSE;
            }
            // 睡眠重试时间，避免太频繁的重试(单位毫秒)
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(this.retyTime));
        }
    }
    
    @Override
    public boolean tryLock() {
    	 final long startTime = System.currentTimeMillis();
        // 是否死循环获取锁
        boolean forever = this.outTime < 0;
        this.outTime = (this.outTime < 0) ? 0:this.outTime;
        
        // 如果没有加锁成功，循环尝试获取锁
        while (true) {
            // 获取成功 退出
            if (lock()) {
            	return Boolean.TRUE;
            }
            // 如果不是必须获取到锁，超过了获取锁的最长时间，退出
            if (!forever && System.currentTimeMillis() - startTime - this.retyTime > this.outTime) {
            	return Boolean.FALSE;
            }
            // 睡眠重试时间，避免太频繁的重试(单位毫秒)
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(this.retyTime));
        }
    }

    @SuppressWarnings("unchecked")
	@Override
    public boolean unLock() {
        Long result = (Long) redisTemplate.execute(RedisScript.of(RELEASE_LOCK_SCRIPT, Long.class),
                Collections.singletonList(lockKey), lockValue);
        return result != null && result > 0;
    }
}


/**
 * 工厂类
 */
@Component
public class RedisFactory {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * @param lockKey
     * @return
     */
    public RedisLock getLock(String lockKey) {
        return new RedisLock(lockKey, redisTemplate);
    }

    /**
     * @param lockKey
     * @param expireTime 锁过期时间
     * @return
     */
    public RedisLock getLock(String lockKey, long expireTime) {
        return new RedisLock(lockKey, expireTime, redisTemplate);
    }
    
    /**
     * 
     * @param lockKey
     * @param expireTime 过期时间
     * @param outTime 请求超时阻塞时间（ 小于0会一直阻塞慎用）
     * @param retyTime 重试时间间隔
     * @return
     */
    public RedisLock getLock(String lockKey, long expireTime, long outTime, long retyTime) {
        return new RedisLock(lockKey,expireTime,outTime,retyTime,redisTemplate);
    }

测试

创建两个定时任务，争取同一个锁，每次只能有一个能执行成功。
测试在一个服务里，实际使用是不同应用服务之间的锁争夺。比如集群和微服务。

@Component
@Slf4j
public class ResendTack {

    @Autowired
    RedisFactory redisFactory;

    /**
     * 5秒执行一次
     */
    @Scheduled(cron = "0/5 * * * * ?")
    public void locTest1() throws InterruptedException {
        log.info("locTest1尝试获取锁");
        Lock lock = redisFactory.getLock("lock_key");
        boolean isLock = lock.lock();
        if (!isLock) {
        log.info("locTest1获取锁失败");
            return;
        }
        try {
            log.info("locTest1获取锁成功");
            TimeUnit.SECONDS.sleep(5);
        } finally {
            log.info("locTest1释放锁");
            lock.unLock();
        }
    }
    
    /**
     * 5秒执行一次
     */
    @Scheduled(cron = "0/5 * * * * ?")
    public void locTest2() throws InterruptedException {
        log.info("locTest2尝试获取锁");
        Lock lock = redisFactory.getLock("lock_key");
        boolean isLock = lock.lock();
        if (!isLock) {
        log.info("locTest2获取锁失败");
            return;
        }
        try {
            log.info("locTest2获取锁成功");
            TimeUnit.SECONDS.sleep(5);
        } finally {
            log.info("locTest2释放锁");
            lock.unLock();
        }
    }
}

结合springAOP

天天用spring开发，肯定要利用spring的优点简化我们的代码的。结合springAOP编程，提供方法级别的注解来使用

注解

/**
 * 分布式锁注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface WithLock {

    /**
     * redis锁的key前缀 如果为空，则默认为类名+方法名+参数
     *
     * @return
     */
    String key() default "";

    /**
     * 锁过期时间默认30秒（单位毫秒）
     *
     * @return
     */
    long expireTime() default 30000L;

    /**
     * 请求锁的超时时间，默认0秒(单位：毫秒)
     *
     * @return
     */
    long outTimet() default 0L;

    /**
     * 重试间隔时间，默认0.5秒(单位：毫秒)
     *
     * @return
     */
    long retryTime() default 500L;

    /**
     * 获取锁失败时候的失败提示
     *
     * @return
     */
    String errorMessage() default "";

}

aop解析

@Aspect
@Component
@Slf4j
public class LockAspect {

    @Autowired
    RedisFactory redisFactory;

    @Pointcut("@annotation(alun.cn.lock.annotion.WithLock)")
    public void lockPoint() {

    }

    @Around(value = "@annotation(withLock)", argNames = "pjp, withLock")
    public Object around(ProceedingJoinPoint pjp, WithLock withLock) throws Throwable {
        Class clazz = pjp.getTarget().getClass();
        String methodName = pjp.getSignature().getName();
        MethodSignature ms = (MethodSignature) pjp.getSignature();
        // 请求的方法参数名称
        ParameterNameDiscoverer d = new DefaultParameterNameDiscoverer();
        // 得到参数名列表

        //分布式锁的key
        StringBuilder key = new StringBuilder("lock:");
        if (withLock.key().equals("")) {
            // key=类名+方法名+参数名
            key.append(clazz.getName() + ":").append(methodName + ":");
            String[] parameterNames = d.getParameterNames(ms.getMethod());
            if (parameterNames.length > 0) {
                key.append(handleParams(Arrays.asList(parameterNames)));
            }
        } else {
            key.append(withLock.key());
        }

        RedisLock redisLock = redisFactory.getLock(key.toString(), withLock.expireTime(), withLock.outTimet(),
                withLock.retryTime());
        Object result = null;
        boolean lockSuccess = false;
        try {
            // 获得锁
            lockSuccess = redisLock.tryLock();
            if (lockSuccess) {
                try {
                    //执行方法
                    result = pjp.proceed();
                } catch (Exception e) {
                    log.error("执行业务发生错误,class={},method={},args={}", clazz.getName(), methodName, pjp.getArgs());
                    throw e;
                }
            } else {
                if (!withLock.errorMessage().equals("")) {
                    log.info(withLock.errorMessage());
                }
            }
        } catch (Exception e) {
            throw new LockException("分布式锁获取时异常", e);
        } finally {
            if (lockSuccess && !redisLock.unLock()) {
                log.error("释放分布式锁失败,class : {},method : {}, key : {}", clazz.getName(), methodName, key);
            }
        }
        return result;
    }

    private String handleParams(List<String> list) {
        final StringBuffer str = new StringBuffer();
        list.forEach(param -> str.append(param).append("_"));
        str.deleteCharAt(str.length() - 1);
        return str.toString();

    }
}

使用

@WithLock(key = "text1",outTimet = 5000,errorMessage = "locTest2请求超时")
public void locTest2() throws InterruptedException {
	 log.info("locTest2获取锁成功");
     TimeUnit.SECONDS.sleep(5);
}

注意

  1. 这个锁必须要设置一个过期时间。否则当一个客户端获取锁成功之后，还没来得及解锁就宕机了，那么它就会一直持有这个锁，而其它客户端永远无法获得这个锁了。

  2. 获取锁的操作和释放锁的操作必须是原子性，所以使用Lua脚本来实现。

  3. value必须要有且唯一，它保证了一个客户端释放的锁必须是自己持有的那个锁。

  4. 不推荐redis集群模式下使用，redis采用的是主从异步复制的策略，这会导致短时间内主库和从库数据短暂的不一致。官方redisson工具已经实现上述所有功能以及针对集群Redlock算法，完全可以拿来直接使用。

  5. 可能会出现业务时间大于锁过期时间（使用守护线程监控过期时间、定时任务事实监控），参考redisson待优化

  6. 多个客户端锁的争夺是随机的，优化方向公平锁

小小dreamer
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis分布式锁实现方案深入探讨（锁重试、锁续租、Redis Module、Redisson、RedLock）
你学废了吗？
05-17 2561
codis 没有pub/sub功能，如果想使用监听+远程唤醒的功能，需要用redis cluster 用zk和etcd实现的分布式锁，都可以使用watcher机制。 但是redis cluster、zk、etcd v2 的发布订阅都会存在惊群效应，一个事件变更，如果有大量的客户端监听，需要一个个远程通知，对这些集群的负载影响很大。 etcd v3，实现了类似java的AQS的clh，有多个监听会形成一个链表，不会一下子唤醒，而是依托前驱唤醒后继。
Redission分布式锁原理以及不可重入不可重试超时释放等问题的解决和详解
m0_73700925的博客
09-23 2156
本博客关于分布式锁的常见问题做出了详细的解答
Redis实战(黑马点评) 分布式锁 redission
m0_59166421的博客
09-20 174
重入问题：重入问题是指 获得锁的线程可以再次进入到相同的锁的代码块中，可重入锁的意义在于防止死锁，比如HashTable这样的代码中，他的方法都是使用synchronized修饰的，假如他在一个方法内，调用另一个方法，那么此时如果是不可重入的，不就死锁了吗？所以可重入锁他的主要意义是防止死锁，我们的synchronized和Lock锁都是可重入的。不可重试：是指目前的分布式只能尝试一次，我们认为合理的情况是：当线程在获得锁失败后，他应该能再次尝试获得锁。超时释放：我们在加锁时增加了过期时间，这样的我们可以防
Redis——构建可重入分布式锁
吴声子夜歌的博客
04-16 270
可重入性是指线程在持有锁的情况下再次请求加锁，如果一个锁支持同一个线程的多次加锁，那么这个锁就是可重入的。比如 Java 语言里有个 ReentrantLock 就是可重入锁。Redis 分布式锁如果要支持可重入，需要对客户端的 set 方法进行包装，使用线程的 Threadlocal 变量 存储当前持有锁的计数。
详解Redisson锁重入、锁重试及超时续约
weixin_64366370的博客
01-11 2159
Redisson锁重入、锁重试及超时续约
浅析Redis分布式锁
12-16
前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务...
Java Redis分布式锁的正确实现方式详解
08-25
主要介绍了Java Redis分布式锁的正确实现方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
redis分布式锁工具类
09-26
现在很多项目单机版已经不满足了，分布式变得越受欢迎，同时也带来很多问题，分布式锁也变得没那么容易实现，分享一个redis分布式锁工具类，里面的加锁采用lua脚本（脚本比较简单，采用java代码实现，无须外部调用...
PHP Redis分布式锁
最新发布
03-23
使用Redis分布式锁时，需要注意设置合适的超时时间和锁的释放机制，以防止因为锁未及时释放导致的资源浪费或系统阻塞等问题。 另外，还需要考虑锁的粒度和范围，尽量减小锁的范围，避免锁的持有时间过长或锁的竞争...
redis分布式锁.zip
10-18
本资源为一步一步实现redis分布式锁的demo，利用redis实现高可用的分布式锁，规避各种坑、坑、坑！
Redis分布式锁实现方式及超时问题解决
08-19
主要介绍了Redis分布式锁实现方式及超时问题解决,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
redis中的乐观锁的实现方式（代码）
荣山的博客
09-23 372
redis中的乐观锁的实现方式
Redis的分布式锁
梁老师教你编程序
11-15 420
当主节点宕机后，主节点的数据还未来得及同步到从节点，进行主从切换后，新的主节点并没有老的主节点的全部数据，这就会导致刚写入到老的主节点的锁在新的主节点并没有，其他服务来获取锁时还是会加锁成功。此时则会有2个服务都可以操作公共资源，此时的分布式锁则是不安全的。因为redis是一个单独的非业务服务，不会受到其他业务服务的限制，所有的业务服务都可以向redis发送写入命令，且只有一个业务服务可以写入命令成功，那么这个写入命令成功的服务即获得了锁，可以进行后续对资源的操作，其他未写入成功的服务，则进行其他处理。
mysql雪花算法主键_分布式主键id生成方式之雪花算法
weixin_35450193的博客
02-08 3562
在分布式环境下，通常都会有主键id或者单号创建的需求。要求在任何情况下生成的主键id或者单号都是不能够重复的，所以我们需要一种主键或者单号生成机制。这里有一下几种方法：1、数据库自增使用mysql数据库的主键id自增2、redis自增3、使用uuid4、雪花算法雪花算法(SnowFlake)，是Twitter开源的分布式id生成算法。其核心思想就是：使用时间戳+工作机器id+序列号生成一个64 b...
【redis 实现分布式锁和重入锁】
qq_35701300的博客
03-16 207
上面的分布式都存在个缺陷，就是程序运行时间超过redis的失效时间，自动释放锁，但是程序没执行完就释放锁，其他线程就可以获得锁了，这违反了我们的初衷了，所以加入看门狗 为其续命。上述锁是不可重入锁，用redis的hash数据结构创建。
Redis实现分布式可重入锁——CAS操作
qq_26678049的博客
03-30 1523
WATCH：监控某些键值对；MULTI：用于开启一个事务；EXEC：执行事务；DISCARD：取消事务；UNWATCH：取消监控。通过watch命令，实现对某些Key的监听，当一个事务提交时，会优先检测监听的key是否发生改变，如果已发生改变，取消事务，若并未改变，执行事务。Lua是一种小巧的脚本语言，redis提供了对lua脚本执行的能力。通过将多个请求通过脚本的形式一次发送，redis会将整个脚本作为一个整体执行，中间不会被其他命令插入。EVAL。
项目实战，用Redis实现分布式锁，支持重试。
weixin_43819764的博客
01-30 2116
背景 对于锁大家肯定不会陌生，在单体系统中， Java 提供的 synchronized 关键字和 ReentrantLock 可重入锁基本能满足我们的需求。 但是随着分布式的快速发展，本地的加锁往往不能满足我们的需要。因为分布式与单机情况下最大的不同在于其不是多线程而是多进程。 多线程由于可以共享堆内存，因此可以简单的采取内存作为标记存储位置。而进程之间甚至可能都不在同一台物理机上，因此需要将标...
分布式全局唯一ID （学习总结---从入门到深化）
12-02 2946
Snowflake常称为雪花算法，是Twitter开源的分布式ID生成算法， 生成后是一个64bit的long型数值，组成部分引入了时间戳，基本保持了自增。Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相 关API的学习成本，提高工作效率，使Java拥有函数式语言般的优 雅，让Java语言也可以“甜甜的”。
java 注解传值_java注解 - Mr.yang.localhost - 博客园
weixin_42301009的博客
02-16 1540
注解使用Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。元注解元注解是指注解的注解。包括 @Retention 、@Target 、@Document 、@Inherited四种。@Retention: 定义注解的保留策略@Ret...
Redis 分布式锁
07-28
Redis分布式锁是一种基于Redis实现的锁机制，用于在分布式系统中实现资源的互斥访问。它通过利用Redis的原子性操作和单线程特性，确保在多个应用实例之间对共享资源进行安全的访问。 Redis分布式锁的实现方式通常有两种： 1. 基于SETNX命令：使用SETNX命令尝试给指定的key设置一个值，如果设置成功，则表示获取到了锁；否则，表示锁已被其他实例占用。在释放锁时，通过DEL命令删除该key。 2. 基于RedLock算法：RedLock是一个由Redis官方提出的分布式锁算法。它使用多个独立的Redis实例来提供高可用性和可靠性。在获取锁时，会尝试在多个Redis节点上同时获取锁；在释放锁时，需要将所有节点上的锁都释放。 无论哪种实现方式，为了避免死锁和误解锁等问题，通常还需要考虑以下几个方面： - 设置合适的锁超时时间，防止死锁。 - 使用唯一标识来区分不同的锁。 - 考虑使用守护线程或定时任务来续约锁的有效期。 - 采用合适的解锁方式，确保只有锁的持有者能够释放锁。 需要注意的是，使用Redis分布式锁时，仍然需要注意并发性和性能问题，避免锁竞争导致的性能瓶颈。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值