redis 分布式锁

2018-12-20 09:33:45来源：博客园阅读 ()

最近抽空优化了之前已有的redis分布式锁，主要用于解决高并发的问题，比如抢红包，多个人同时操作红包库存，当在库存只剩下1个的时候，一个人的减库存的操作事务没提交，另一个人的查库存操作刚好同步执行，这样就会出现很尴尬的事情，1个红包会被2个人抢走，这个时候，我们就要依托锁，将请求入口锁住，当然锁有很多种方式，这边就记录一下比较好用的redis分布式锁。

方式有很多setNX 、set、incr等等，setNX只要通过逻辑防止死锁就可以了

直接上代码：

public boolean keyLock(final String key, final long keepMin) {
        boolean obj = false;
        try {
            obj = (boolean) redisTemplateSerializable.execute(new RedisCallback<Object>() {
                
                @Override
                public Object doInRedis(RedisConnection connection)
                        throws DataAccessException {
                    try{
                        Long incr = connection.incr(key.getBytes());
                        if(incr == 1){
                            connection.setEx(key.getBytes(), keepMin, incr.toString().getBytes());
                            return true;
                        }else{
                            Long ttl = connection.ttl(key.getBytes());
                            if(ttl == -1){
                                //设置失败,重新设置过期时间
                                connection.setEx(key.getBytes(), keepMin, incr.toString().getBytes());
                                return true;
                            }
                        }
                    }catch (Exception e) {
                        logger.error("加锁异常", e);
                        connection.del(key.getBytes());
                        return true;
                    }
                    
                    return false;
                }
    
            });
        }catch (Exception e) {
             logger.error(e.getMessage());
        }
        
         return obj;
    }

注解

package com.tp.soft.common.interceptor;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;

/**
 * redis锁注解
 * 
 * @author taop
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
@Documented
public @interface RedisLock {
    String lockName() default ""; // 锁名
    int retryTimes() default 0; // 重试次数
    long retryWait() default 200; // 重试等待时间,单位 : ms
    int keeyMinTime() default 1; //锁自动失效时间 1秒
}

aop

package com.tp.soft.aop.redis;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.commons.lang.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import cn.hutool.core.lang.Assert;

import com.tp.soft.common.interceptor.Cacheable;
import com.tp.soft.common.interceptor.RedisLock;
import com.tp.soft.redis.RedisCacheSvc;

@Aspect
@Component
public class RedisLockAop {

    private static final Logger log = LoggerFactory.getLogger(RedisLockAop.class);
    
    private static final String LOCK_NAME = "lockName";
    private static final String RETRY_TIMES = "retryTimes";
    private static final String RETRY_WAIT = "retryWait";
    private static final String KEEP_MIN_TIME = "keepMinTime";

    @Resource
    private RedisCacheSvc redisCacheSvc;

    @Pointcut("@annotation(com.tp.soft.common.interceptor.RedisLock)")
    public void redisLockAspect() {
    }

    @Around("redisLockAspect()")
    public Object lockAroundAction(ProceedingJoinPoint pjp) throws Throwable {
        Method method = returnMethod(pjp);
        
        Map<String, Object> annotationArgs = this.getAnnotationArgs(pjp);
        String lockPrefix = (String) annotationArgs.get(LOCK_NAME);
        Assert.notNull(lockPrefix, "分布式,锁名不能为空");
        
        int retryTimes = (int) annotationArgs.get(RETRY_TIMES);
        long retryWait = (long) annotationArgs.get(RETRY_WAIT);
        int keepMinTime = (int) annotationArgs.get(KEEP_MIN_TIME);
        String keyName = parseKey(lockPrefix, method, pjp.getArgs());
        
        // 获取redis锁,防止死锁
        boolean keyLock = redisCacheSvc.keyLock(keyName, keepMinTime);
        if(keyLock){
            //执行主程序
            return pjp.proceed();
        }else{
            if(retryTimes <= 0){
                 log.info(String.format("{%s}已经被锁, 不重试", keyName));
                 throw new RuntimeException(String.format("{%s}已经被锁, 不重试", keyName));
            }
            
            int failCount = 1;
            while (failCount <= retryTimes) {
                // 等待指定时间ms
                try {
                    Thread.sleep(retryWait);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (redisCacheSvc.keyLock(keyName, keepMinTime)) {
                    // 执行主逻辑
                    return  pjp.proceed();
                } else {
                    log.info(String.format("{%s}已经被锁, 正在重试[ %s/%s ],重试间隔{%s}毫秒", keyName, failCount, retryTimes, retryWait));
                    failCount++;
                }
            }
            
            throw new RuntimeException("系统繁忙, 请稍等再试");

        }
        

    }


    /**
     * 获取锁参数
     * 
     * @param proceeding
     * @return
     */
    private Map<String, Object> getAnnotationArgs(ProceedingJoinPoint proceeding) {
        Class target = proceeding.getTarget().getClass();
        Method[] methods = target.getMethods();
        String methodName = proceeding.getSignature().getName();
        for (Method method : methods) {
            if (method.getName().equals(methodName)) {
                Map<String, Object> result = new HashMap<String, Object>();
                RedisLock redisLock = method.getAnnotation(RedisLock.class);
                result.put(LOCK_NAME, redisLock.lockName());
                result.put(RETRY_TIMES, redisLock.retryTimes());
                result.put(RETRY_WAIT, redisLock.retryWait());
                result.put(KEEP_MIN_TIME, redisLock.keeyMinTime());
                return result;
            }
        }
        return null;
    }

    private Method returnMethod(ProceedingJoinPoint pjp)
            throws NoSuchMethodException {
        Signature signature = pjp.getSignature();
        Class<? extends Object> cls = pjp.getTarget().getClass();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method targetMethod = methodSignature.getMethod();
        Method method = cls.getDeclaredMethod(signature.getName(),
                targetMethod.getParameterTypes());
        return method;
    }

    /**
     * 获取缓存的key key 定义在注解上，支持SPEL表达式
     * 
     * @param pjp
     * @return
     */
    private String parseKey(String key, Method method, Object[] args) {

        // 获取被拦截方法参数名列表(使用Spring支持类库)
        LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
        String[] paraNameArr = u.getParameterNames(method);

        // 使用SPEL进行key的解析
        ExpressionParser parser = new SpelExpressionParser();
        // SPEL上下文
        StandardEvaluationContext context = new StandardEvaluationContext();
        // 把方法参数放入SPEL上下文中
        for (int i = 0; i < paraNameArr.length; i++) {
            context.setVariable(paraNameArr[i], args[i]);
        }
        return parser.parseExpression(key).getValue(context, String.class);
    }
}

搭建完成后直接在需要锁住的接口上注解

@RedisLock(lockName="'lock_'+#tbbId",retryTimes=5)

模拟高并发测试

for (int i = 0; i < 2; i++) {
            threadPoolTaskExecutor.execute(new StartTaskThread(redisCacheSvc, i, threadPoolTaskExecutor));
        }

效果就是这样了

菜鸟的思路，各位大神有好的思路请留言...

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Spring中的Bean配置

下一篇：2018-12-20 第一章初识JAVA-上机

redis缓存 2020-06-12
Spring Boot 2.3.0 新特性Redis 拓扑动态感应 2020-06-11
聊聊微服务架构及分布式事务解决方案！ 2020-06-10
作为一个面试官，我想问问你Redis分布式锁怎么搞？ 2020-06-10
分布式锁没那么难，手把手教你实现 Redis 分布锁！|保姆级教 2020-06-08

IDC资讯：主机资讯注册资讯托管资讯 vps资讯网站建设

网站运营：建站经验策划盈利搜索优化网站推广免费资源

网站联盟：联盟新闻联盟介绍联盟点评网赚技巧

行业资讯：搜索引擎网络游戏电子商务广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器安全防护

软件技巧：其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识：网络协议网络安全网络管理组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条

最新资讯

热门关注

热门标签