基于切面和注解的Redis分布式锁实现

描述

  • 基于SpringEL表达式,动态配置
  • 基于切面,无缝切入
  • 支持获取锁失败时的行为,抛出异常还是继续等待,两种方式的锁,一种等待重试,一种直接退出

源码地址:https://github.com/shawntime/shawn-common-utils/tree/master/src/main/java/com/shawntime/common/lock

使用方法

@RedisLockable(key = {"#in.activityId", "#in.userMobile"}, expiration = 120, isWaiting = true, retryCount = 2)
@Override
public PlaceOrderOut placeOrder(OrderIn in) {
    // ------
}

代码实现

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

    String prefix() default "";

    String[] key() default "";

    long expiration() default 60;

    boolean isWaiting() default false; //锁是否等待,默认为不等待

    int retryCount() default -1; // 锁等待重试次数,-1未不限制

    int retryWaitingTime() default 10; // 锁等待重试间隔时间,默认10毫秒
}
@Aspect
@Component
public class RedisLockInterceptor {

    private static final LocalVariableTableParameterNameDiscoverer DISCOVERER = new LocalVariableTableParameterNameDiscoverer();

    private static final ExpressionParser PARSER = new SpelExpressionParser();

    @Pointcut("@annotation(com.shawntime.common.lock.RedisLockable)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint point) throws Throwable {

        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        Method targetMethod = AopUtils.getMostSpecificMethod(methodSignature.getMethod(), point.getTarget().getClass());
        String targetName = point.getTarget().getClass().getName();
        String methodName = point.getSignature().getName();
        Object[] arguments = point.getArgs();

        RedisLockable redisLock = targetMethod.getAnnotation(RedisLockable.class);
        long expire = redisLock.expiration();
        String redisKey = getLockKey(redisLock, targetMethod, targetName, methodName, arguments);
        String uuid;
        if (redisLock.isWaiting()) {
            uuid = waitingLock(redisKey, expire, redisLock.retryCount(), redisLock.retryWaitingTime());
        } else {
            uuid = noWaitingLock(redisKey, expire);
        }
        if (StringUtils.isNotEmpty(uuid)) {
            try {
                return point.proceed();
            } finally {
                RedisLockUtil.unLock(redisKey, uuid);
            }
        } else {
            throw new RedisLockException(redisKey);
        }
    }

    private String getLockKey(RedisLockable redisLock, Method targetMethod,
                              String targetName, String methodName, Object[] arguments) {
        String[] keys = redisLock.key();
        String prefix = redisLock.prefix();
        StringBuilder sb = new StringBuilder("lock.");
        if (StringUtils.isEmpty(prefix)) {
            sb.append(targetName).append(".").append(methodName);
        } else {
            sb.append(prefix);
        }
        if (keys != null) {
            String keyStr = Joiner.on("+ '.' +").skipNulls().join(keys);
            EvaluationContext context = new StandardEvaluationContext(targetMethod);
            String[] parameterNames = DISCOVERER.getParameterNames(targetMethod);
            for (int i = 0; i < parameterNames.length; i++) {
                context.setVariable(parameterNames[i], arguments[i]);
            }
            Object key = PARSER.parseExpression(keyStr).getValue(context);
            sb.append("#").append(key);
        }
        return sb.toString();
    }

    private String noWaitingLock(String key, long expire) {
        return RedisLockUtil.lock(key, expire);
    }

    private String waitingLock(String key, long expire, int retryCount, int retryWaitingTime)
            throws InterruptedException {
        int count = 0;
        while (retryCount == -1 || count <= retryCount) {
            String uuid = noWaitingLock(key, expire);
            if (!StringUtils.isEmpty(uuid)) {
                return uuid;
            }
            try {
                TimeUnit.MILLISECONDS.sleep(retryWaitingTime);
            } catch (InterruptedException e) {
                throw e;
            }
            count++;
        }
        return null;
    }
}
/**
 * 分布式锁工具类
 */
public final class RedisLockUtil {

    private static final int DEFAULT_EXPIRE = 60;

    private static final String SCRIPT =
            "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n"
            + "then\n"
            + "    return redis.call(\"del\",KEYS[1])\n"
            + "else\n"
            + "    return 0\n"
            + "end";

    private RedisLockUtil() {
        super();
    }

    /**
     *
     * @param key 锁的key
     * @return 返回value为null,则锁失败,不为null则锁成功
     */
    public static String lock(String key) {
        return lock(key, DEFAULT_EXPIRE);
    }

    public static boolean lock(String key, String value) {
        return lock(key, value, DEFAULT_EXPIRE);
    }

    public static String lock(String key, long expire) {
        String value = UUID.randomUUID().toString();
        boolean nx = SpringRedisUtils.setNX(key, value, expire);
        return nx ? value : null;
    }

    public static boolean lock(String key, String value, long expire) {
        return SpringRedisUtils.setNX(key, value, expire);
    }

    public static void unLock(String key, String value) {
        SpringRedisUtils.lua(SCRIPT, Collections.singletonList(key), Collections.singletonList(value));
    }
}

redis分布式锁的三种实现

第一种:使用setnx()、get()、getset()方法

> SETNX命令(SET if Not eXists)\
语法:SETNX key value\
功能:原子性操作,当且仅当 key 不存在,将 key 的值设为 value ,并返回1;若给定的 key 已经存在,则 SETNX 不做任何动作,并返回0。\
GETSET命令\
语法:GETSET key value\
功能:将给定 key 的值设为 value ,并返回 key 的旧值 (old value),当 key 存在但不是字符串类型时,返回一个错误,当key不存在时,返回nil。\
GET命令\
语法:GET key\
功能:返回 key 所关联的字符串值,如果 key 不存在那么返回特殊值 nil 。\
DEL命令\
语法:DEL key [KEY …]\
功能:删除给定的一个或多个 key ,不存在的 key 会被忽略。

  • setnx(lockkey, 当前时间+过期超时时间) ,如果返回1,则获取锁成功;如果返回0则没有获取到锁,转向2。
  • get(lockkey)获取值oldExpireTime ,并将这个value值与当前的系统时间进行比较,如果小于当前系统时间,则认为这个锁已经超时,可以允许别的请求重新获取,转向3。
  • 计算newExpireTime=当前时间+过期超时时间,然后getset(lockkey, newExpireTime) 会返回当前lockkey的值currentExpireTime。
  • 判断currentExpireTime与oldExpireTime 是否相等,如果相等,说明当前getset设置成功,获取到了锁。如果不相等,说明这个锁又被别的请求获取走了,那么当前请求可以直接返回失败,或者继续重试。
  • 在获取到锁之后,当前线程可以开始自己的业务处理,当处理完毕后,比较自己的处理时间和对于锁设置的超时时间,如果小于锁设置的超时时间,则直接执行delete释放锁;如果大于锁设置的超时时间,则不需要再锁进行处理。
/**
 * 等待锁
 *
 * @param key    redis key
 * @param expire 过期时间,单位秒
 * @return true:加锁成功,false,加锁失败
 */
private boolean waitingLock(String key, long expire, int retryCount) {
    int count = 0;
    while (retryCount == -1 || count <= retryCount) {
        if (noWaitingLock(key, expire)) {
            return true;
        }
        try {
            TimeUnit.MILLISECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count++;
    }
    return false;
}

/**
 * 加锁
 *
 * @param key    redis key
 * @param expire 过期时间,单位秒
 * @return true:加锁成功,false,加锁失败
 */
private boolean noWaitingLock(String key, long expire) {
    long value = System.currentTimeMillis() + expire * 1000;
    long status = redisClient.setnx(key, value);
    if (status == 1) {
        return true;
    }
    long oldExpireTime = Long.parseLong(redisClient.get(key, "0", false));
    if (oldExpireTime < System.currentTimeMillis()) {
        long newExpireTime = System.currentTimeMillis() + expire * 1000;
        String currentExpireTimeStr = redisClient.getSet(key, String.valueOf(newExpireTime));
        if (StringUtils.isEmpty(currentExpireTimeStr)) {
            return true;
        }
        long currentExpireTime = Long.parseLong(currentExpireTimeStr);
        if (currentExpireTime == oldExpireTime) {
            return true;
        }
    }
    return false;
}

private void unLock(String key, long startTime, long expire) {
    long parseTime = System.currentTimeMillis() - startTime;
    if (parseTime <= expire * 1000) {
        redisClient.del(key);
    }

}

通过SET key value [EX seconds] [PX milliseconds] [NX|XX]实现

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 :只在键已经存在时,才对键进行设置操作。

private boolean noWaitingLock2(String key, String uuid, long expire) {
    String value = redisClient.setnx(key, uuid, expire);
    return value != null;
}

private boolean waitingLock2(String key, String uuid, long expire, int retryCount) {
    int count = 0;
    while (retryCount == -1 || count <= retryCount) {
        if (noWaitingLock2(key, uuid, expire)) {
            return true;
        }
        try {
            TimeUnit.MILLISECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count++;
    }
    return false;
}

删除锁的机制直接使用del不可行,因为有可能导致误删别人的锁的情况。
比如,这个锁我上了10s,但是我处理的时间比10s更长,到了10s,这个锁自动过期了,被别人取走了,并且对它重新上锁了。那么这个时候,我再调用Redis::del就是删除别人建立的锁了。
使用lua脚本,先进行get,再进行del

private static final String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
            "then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end";

private void unLock2(String key, String uuid) {
    Object result = redisClient.lua(script, Collections.singletonList(key), Collections.singletonList(uuid));
    System.out.println(result);
}

public Object lua(final String script, List<String> keys, List<String> args) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.eval(script, keys, args);
        } catch (Exception ex) {
            LOGGER.error(ex);
            return 0;
        } finally {
            returnResource(jedis);
        }
    }

Redissons实现分布式锁

RLock rLock = redisson.getLock(lockKey);
long expired = lock.expire();
boolean isLock = rLock.tryLock(expired, TimeUnit.SECONDS);

if (isLock) {
    try {
        // 处理
    } finally {
        rLock.unlock();
    }
}

rLock.tryLock(3, expired, TimeUnit.SECONDS);
发布了3 篇原创文章 · 获赞 0 · 访问量 120
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 数字20 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览