基于RedisTemplate的redis分布式锁, 以及注解实现

最新推荐文章于 2024-07-22 02:07:29 发布
最新推荐文章于 2024-07-22 02:07:29 发布
阅读量906 收藏 1
点赞数 2
分类专栏： Spring Boot Java Redis 文章标签： redis spring data redis spring boot 分布式 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41910280/article/details/88837576
版权
Java 同时被 3 个专栏收录
10 篇文章 0 订阅
订阅专栏
Spring Boot
7 篇文章 1 订阅
订阅专栏
Redis
3 篇文章 0 订阅
订阅专栏

基于Redis的分布式锁最佳实践

欢迎转载，转载请注明网址:https://blog.csdn.net/qq_41910280

版本说明
2019-03-07 初始版本
2020-06-17 新增springboot 1.5版本代码
2021-12-07 1.加锁改为使用lua脚本，解耦对jedis的依赖，可以使用lutte、redisson、jedis等任意客户端
　　　　2.增加redisson的分布式锁
　　　　本文不再更新，新地址为https://blog.csdn.net/qq_41910280/article/details/121769533

简介
　　本文基于spring data redis完成了redis分布式锁, 以及注解实现。Talk is cheap, let’s Getting Started.

文章目录

1. 环境

　　redis: 5.0.0
　　spring data redis：2.1.5
　　spring boot: 2.1.3.RELEASE

2. 核心代码

　　主要注意: 上锁lock 以及 解锁unlock 的原子性操作, 以此避免了死锁或误删其他线程或服务所上的锁

2. 1 springboot 2.0以上版本代码

package com.example.lock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * @author zhouyou
 * @blog https://blog.csdn.net/qq_41910280
 */
@Component
public class RedisLockTool {
    private static final Logger logger = LoggerFactory.getLogger(RedisLockTool.class);
    @Autowired
    StringRedisTemplate redisTemplate;
    /**
     * 存放本台服务器注册的所有key, 定期对所有的key设置过期时间操作
     */
    private Map<String, String> keepAliveLocks = new ConcurrentHashMap<>();
    private final Timer timer = new Timer();
    private static StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    @Value("${redis.lock.aliveMilis:600000}")
    private long aliveMilis;
    @Value("${redis.lock.intervalMilis:300000}")
    private long intervalMilis;

    /**
     * 分布式锁lock
     * @param key         锁名
     * @param id          标识符, 只有同一个id才能解key锁
     * @param expireMilis 超时时间, (expireMilis==-1 && keepAlive=false)表示为永不过期
     * @param keepAlive   是否让key锁保持alive
     * @return
     */
    public Boolean lock(String key, String id, long expireMilis, boolean keepAlive) {
        logger.info("lock入参 key={}, id={}, expireMilis={}, keepAlive={}", key, id, expireMilis, keepAlive);
        Boolean execute = redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            RedisStringCommands redisStringCommands = connection.stringCommands();
            Boolean set = redisStringCommands.set(stringRedisSerializer.serialize(key), stringRedisSerializer.serialize(id),
                    Expiration.milliseconds(expireMilis), RedisStringCommands.SetOption.SET_IF_ABSENT);
            connection.close();
            return set;
        });
        logger.info("lock 出参 execute={}",execute);
        if (execute && keepAlive) {
            keepAliveLocks.put(key, "");
            keeplockAlive();
        }
        return execute;
    }

    //在bean初始化完成之后启动timer，在timer任务中给锁续命
    @PostConstruct
    private void init() {
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                keeplockAlive();
            }
        }, 0, intervalMilis);
    }

    //在销毁之前将timer取消
    @PreDestroy
    private void destroy() {
        timer.cancel();
    }

    private void keeplockAlive() {
        if (keepAliveLocks.size() > 0) {
            for (String key : keepAliveLocks.keySet()) {
                redisTemplate.expire(key, aliveMilis, TimeUnit.MILLISECONDS);
            }
        }
    }

    /**
     * 解锁 解铃还需系铃人
     * @param key 锁名
     * @param id  标识符, id相同才能解锁
     * @return 1.id相同而且key没有过期 2.key过期id=null 返回true
     */
    public boolean unlock(String key, String id) {
        /*
        必须先从concurrentHashMap中删除 再删redis的key
        避免其他线程中途刚在redis注册key就被从concurrentHashMap删除
         */
        String redisId = redisTemplate.opsForValue().get(key);
        logger.info("unlock入参 key={}, id={}; redis中id={}", key, id, redisId);
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return '0' end";
        if (Objects.equals(id, redisId)) {
            keepAliveLocks.remove(key);
            /*
            不直接使用redisTemplate.delete(key)
            因为可能在delete之前刚好key过期并且key被另一线程或机器注册导致误删
             */
            Long execute = redisTemplate.execute((RedisScript<Long>) RedisScript.of(script, Long.class),// java的Long对应redis的integer
//                    stringRedisSerializer, new GenericJackson2JsonRedisSerializer(),
                    Collections.singletonList(key), id);
            // 与上述方法相同
//            Object execute = redisTemplate.execute(
//                    (RedisConnection connection) -> connection.eval(
//                            script.getBytes(),
//                            ReturnType.INTEGER,
//                            1,
//                            key.getBytes(),
//                            id.getBytes())
//            );
            logger.info("unlock 出参 execute={}", execute);
            return Objects.equals(execute, 1L);
        }
        return false;
    }

}

2. 2 springboot 1.5版本代码


import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Collections;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * redis分布式锁
 *
 * @author zhouyou
 * @date 2020/1/17 17:22
 * @email zhouyouchn@126.com
 * 版权声明：本文为CSDN博主「Spark4J」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
 * 原文链接：https://blog.csdn.net/qq_41910280/article/details/88837576
 */
@Component
public class RedisLockTool {
    private static final Logger logger = LoggerFactory.getLogger(RedisLockTool.class);
    private final StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    private static final RedisSerializer<Long> VALUE_SERIALIZER = new FastJsonRedisSerializer(Long.class);
    @Autowired
    StringRedisTemplate redisTemplate;
    private static final long DEFAUT_WAIT_MS = 120_000L;
    private static final RedisScript<Long> SCRIPT = new DefaultRedisScript("if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return '0' end", Long.class);

    /**
     * 加锁
     *
     * @param key         锁的key
     * @param identifier  锁标识
     * @param lockTimeout 锁的超时时间 毫秒
     * @return 锁标识 null表示加锁失败
     */
    public String lock(String key, String identifier, long lockTimeout) {
        return lock(key, identifier, lockTimeout, DEFAUT_WAIT_MS);
    }

    /**
     * 加锁
     *
     * @param key         锁的key
     * @param identifier  锁标识
     * @param lockTimeout 锁的超时时间 毫秒
     * @return 锁标识 null表示加锁失败
     */
    public String lock(String key, String identifier, long lockTimeout, long waitTimeout) {
        identifier = getIdentifier(identifier);
        key = getKey(key);
        // 根据并发调整超时时间
        long end = System.currentTimeMillis() + waitTimeout;
        while (System.currentTimeMillis() < end) {
            if (setNx(key, identifier, lockTimeout)) {
                // 返回value值，用于释放锁时间确认
                logger.info("lock success, key:{}, identifier:{}", key, identifier);
                return identifier;
            } else {
                logger.info("lock fail, key:{}", key);
            }

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        return null;
    }

    /**
     * 加锁 不等待 直接返回
     * 用于分布式中只需要一个服务进行运算
     *
     * @param key        锁的key
     * @param identifier 锁标识
     * @param timeout    锁的超时时间 毫秒
     * @return 锁标识 null表示加锁失败
     */
    public String lockNoWait(String key, String identifier, long timeout) {
        identifier = getIdentifier(identifier);
        key = getKey(key);
        if (setNx(key, identifier, timeout)) {
            // 返回value值，用于释放锁时间确认
            logger.info("lock success, key:{}, identifier:{}", key, identifier);
            return identifier;
        } else {
            logger.info("lock fail, key:{}", key);
        }
        return null;
    }

    /**
     * 重置锁时效
     *
     * @param keyName    锁的key
     * @param identifier 锁标识
     * @param timeout    锁的超时时间 毫秒
     * @return 锁标识 null表示失败
     */
    public String resetLockExp(String keyName, String identifier, long timeout) {
        identifier = getIdentifier(identifier);
        String lockKey = getKey(keyName);

        if (identifier.equals(getValue(lockKey))) {
            expireByMill(lockKey, timeout);
            // 返回value值，用于释放锁时间确认
            logger.info("reset lock success, key:{}, id:{}", lockKey, identifier);
            return identifier;
        } else {
            logger.info("reset lock fail, key:{}", lockKey);
            return null;
        }

    }

// TimeUtils只是我基于jdk8时间类编写的工具类 这里是获得uuuuMMddHHmmss格式
    private String getIdentifier(String identifier) {
        if (StringUtils.isBlank(identifier)) {
            identifier = TimeUtils.now(TimeUtils.ISO_DATETIME_WITHOUT_HYPHEN) + "-" + getLocalHostName();
        }
        return identifier;
    }

    /**
     * 释放锁
     *
     * @param key        锁的key
     * @param identifier 释放锁的标识
     * @return
     */
    public boolean unlock(String key, String identifier) {
        key = getKey(key);
        // 此为方法一 或直接采用jedis执行脚本
        Long execute = redisTemplate.execute(SCRIPT, redisTemplate.getStringSerializer(), VALUE_SERIALIZER, Collections.singletonList(key), identifier);
        return Objects.equals(execute, 1L);
    }

    public String getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public String getLockValue(String key) {
        return redisTemplate.opsForValue().get(getKey(key));
    }

    public String getKey(String keyName) {
        return "LOCK:" + keyName;
    }

    private String getLocalHostName() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            logger.error("InetAddress.getLocalHost出现异常", e);
            return StringUtils.EMPTY;
        }
    }

    private void remove(String key) {
        redisTemplate.delete(key);
    }

    private boolean setNx(final String key, final String value, long ms) {
        boolean b = false;
        try {
            b = redisTemplate.execute((RedisCallback<Boolean>) connection -> {
                Jedis jedis = (Jedis) connection.getNativeConnection();
                String set = jedis.set(key, value, "NX", "PX", ms);
                return "OK".equals(set);
            });
        } catch (Exception e) {
            logger.error("redis setNxEx error, key : {}", key);
        }
        return b;
    }

    private void expireByMill(String key, long exp) {
        redisTemplate.expire(key, exp, TimeUnit.MILLISECONDS);
    }

    /**
     * @param key
     * @return 秒
     */
    public Long ttl(String key) {
        return redisTemplate.getExpire(key);
    }
}

　　…

3. 注解

1.注解类

/**
 * 分布式同步锁
 */
package com.example.annotation;

import java.lang.annotation.*;

/**
 * 分布式同步锁
 */
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisSynchronized {
    String value() default "";

    String id() default "no identifier";

    long expireMilis() default 60000L;
}

2.处理注解的类

package com.example.annotation;

import com.example.lock.RedisLockTool;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
public class RedisLockAutoProxyCreator implements BeanPostProcessor, ApplicationContextAware {
    @Autowired
    RedisLockTool redisLockTool;
//    private Map<String, ReflectiveMethodInvocation> fallbackInvocations = new HashMap<String, ReflectiveMethodInvocation>();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> clazz = AopUtils.getTargetClass(bean);
        for (Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(RedisSynchronized.class)) {
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(clazz);
                enhancer.setCallback(new RedisLockAnnotationHandler(bean));
                return enhancer.create();
            }
        }
        return bean;
    }

    class RedisLockAnnotationHandler implements InvocationHandler {
        private Object o;

        RedisLockAnnotationHandler(Object o) {
            this.o = o;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (!method.isAnnotationPresent(RedisSynchronized.class)) {
                return method.invoke(o, args);
            }
            RedisSynchronized annotation = method.getAnnotation(RedisSynchronized.class);
            String key = annotation.value();
            if ("".equals(key)) {
                key = method.toGenericString();
            }
            String id = annotation.id();
            long expireMilis = annotation.expireMilis();
            for (int i = 0; i < 400; i++) {
                boolean locked = redisLockTool.lock(key, id, expireMilis, false);// false避免服务器崩溃造成死锁
                if (locked) {
                    try {
                        return method.invoke(o, args);
                    } finally {
                        redisLockTool.unlock(key, id);
                    }
                }
                Thread.sleep(300);
            }
            throw new RuntimeException("lock fail, key=" + key);
        }

    }
}

测试代码:

@RequestMapping("/annotationTest")
    @ResponseBody
    @RedisSynchronized("123")
    public String annotationTest() throws Exception {
            System.out.println("do something");
            Thread.sleep(30000);
        return "annotationTest over";
    }
    @RequestMapping("/annotationTest2")
    @ResponseBody
    @RedisSynchronized("123")
    public String annotationTest2() throws Exception {
        System.out.println("do something");
        Thread.sleep(30000);
        return "annotationTest over";
    }

就个人而言, 注解没有直接使用RedisLockTool灵活

参考文献

1.https://zhuanlan.zhihu.com/p/48156279 (有更完善的注解实现)
2.https://wudashan.cn/2017/10/23/Redis-Distributed-Lock-Implement/

神奇的小尾巴：
本人邮箱：zhouyouchn@126.com zhoooooouyou@gmail.com
zhouyou@whut.edu.cn　欢迎交流，共同进步。
欢迎转载，转载请注明本网址。
Spark4J
关注
专栏目录
redis 分布式锁
weixin_58361879的博客
06-20 878
redis手写分布式锁
Java三种方式实现redis分布式锁
guanshengg的博客
08-05 1856
在分布式服务中，常常有如定时任务、库存更新这样的场景。 在定时任务中，如果不使用quartz这样的分布式定时工具，只是简单的使用定时器来进行定时任务，在服务分布式部署中，就有可能存在定时任务并发执行，造成一些问题。 在库存更新这样的场景中，我们服务对数据库同一条记录进行更新，并记录。对记录更新可以使用分布式锁，但对操作进行记录时，可能造成读未提交，造成记录错乱的情况。 在以上的场景中，我们引入了分布式事务锁...
浅析Redis分布式锁
12-16
近期工作遇到需要业务场景如下,需要每天定时推送给另一系统一批数据,但是由于系统是集群部署的,会造成统一情况下任务争用的情况,所以需要增加分布式锁来保证一定时间范围内有一个Job来完成定时任务. 前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务抢占这一功能 记录一下走过的弯路. 第一版本: @Override public <T> Long set(String key,T value, Long c
Redis分布式锁最佳实践
LFH_121的专栏
06-12 448
1.1分布式锁的注意事项 互斥性：在任意时刻，只有一个客户端能持有同一把锁； 同一性：加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给释放了。 可重入性：即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能成功加锁（锁到期会自动释放）。 1.2 实现原理 1.3 代码实现 import redis.clients.jedis.Jedis; imp...
分布式锁的最佳实践之Redisson
最新发布
weixin_40564158的博客
07-22 30
本文接从库存超卖问题分析锁和分布式锁的应用（二）讲解Redisson在分布式锁的应用实践。官网文档地址：https://github.com/redisson/redisson/wikiRedisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分...
Redis分布式锁的最佳实践
专注于Java技术、软件架构设计、数据分析
05-20 594
原文链接：https://www.jianshu.com/p/8cc44d008177 使用redis的SET resource-name anystring NX EX max-lock-time 方式，用于分布式锁 实现原理 命令 SET resource-name anystring NX EX max-lock-time 是一种在 Redis 中实现锁的简单方法。 客户端执行以上的...
Redis分布式锁的最佳实践 - Redisson
xcbeyond|疯狂源自梦想，技术成就辉煌
04-18 1188
Redisson 实现分布式锁本文只介绍Redisson如何实现分布式锁的原理。 一、高效分布式锁当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的...
Redis实现分布式锁的六种方式。最佳实践：原子性获取锁+LUA脚本释放锁
weixin_43989347的博客
06-19 1981
redis实现分布式锁
spring mvc + redis 实现分布式锁（注解实现可自动重试）
yujunyi的博客
10-22 2046
分布式锁一般有三种实现方式：1. 数据库乐观锁；2. 基于 Redis 的分布式锁；3. 基于 ZooKeeper 的分布式锁。本文介绍基于 Redis 实现分布式锁
「分布式技术」分布式锁的最佳实践
frozenpenguin的博客
03-13 1276
在传统的单体服务中，我们经常会遇到多线程对于单一资源的抢占导致的线程安全问题以及对数据库数据操作的一致性问题，如果是在单体系统中，我们可以很方便的使用编程语言提供的锁以及数据库事务来解决这些问题。
redis实现分布式锁工具类
婲落ヽ红颜谇的博客
09-23 453
工具类代码 package cn.com.yiyongcloud.testRedisLock; import redis.clients.jedis.Jedis; import java.util.Collections; //redis实现分布式锁工具类 public class RedisLockUtil { private static final String LOCK_SUCCESS = "OK"; private static final String SET_IF_NOT_EX
redis实现分布式锁 工具类
小小码农
01-11 1207
/** * @description: Redis 分布式锁 * @author: cy * @create: 2020-07-10 **/ @Slf4j @Component public class RedisLock { private final RedisTemplate<String, Object> redisTemplate; private final ThreadLocal<String> localKeys = new ThreadLocal
redis分布式锁的工具类
hecr_mingong的博客
12-04 409
1.demo package com.hecr; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisCallback; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Component; i
Redis分布式锁最佳实践，助你实现高性能、高并发的分布式应用
资料免费分享，点击名片
10-26 212
数据库乐观锁；基于Redis的分布式锁；基于ZooKeeper的分布式锁本篇博客将介绍第二种方式，基于Redis实现分布式锁。虽然网上已经有各种介绍Redis分布式锁实现的博客，然而他们的实现却有着各种各样的问题，为了避免误人子弟，本篇博客将详细介绍如何正确地实现Redis分布式锁。本文主要介绍了如何使用Java代码正确实现Redis分布式锁，对于加锁和解锁也分别给出了两个比较经典的错误示例。其实想要通过Redis实现分布式锁并不难，只要保证能满足可靠性里的四个条件。
分布式锁工具类
weixin_43635191的博客
12-10 209
package com.guangxun.car.service; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.data.redis.co...
Redis实现分布式锁及工具类
weixin_48974246的博客
07-28 736
redis分布式锁工具类
redis分布式锁工具类
IT从业者
12-01 1672
import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.data.redis.core.RedisTemplate; import java.util.concurrent.TimeUnit; /** * 并发工具类 * author: zhanggw * 创建时间: 2021/1/19 */ public class ConcurrentUtils { private s.
基于codis实现分布式锁
wzp1986的专栏
11-19 1518
文章目录初始化JedisResourcePool使用原子操作来申请与释放锁 mariadb为方便oracle用户迁移，在10.3版本起，支持sequence。 初始化JedisResourcePool RoundRobinJedisPool会 轮流连接当前可用的codisProxy @ConfigurationProperties(prefix = &quot;codis&quot;) public class ...
Java实现Redis分布式锁详解
在Java中实现Redis分布式锁是一种常见的技术实践，特别是在需要处理高并发场景和确保数据一致性时。本文档介绍了如何通过`RedisLockService`类来利用Spring框架与Redis进行交互，实现分布式锁功能。`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值