Java 分布式锁实现的一些实践

近期换工作，闲下来有点时间写点东西，在这里分享一些心得体会

背景：我们在做后端开发时，无法避免的会遇到一些一致性问题，有时候我们前端的小伙伴或者rpc接口的调用方，在很短的时间间隔内给我们相同的请求，由此可能会导致一些无法预见的问题，因此需要我们在接口层面处理，下面给大家分享一下我解决此类问题的一些实践

思路：1、加锁解锁的逻辑与正常的业务逻辑需要分开，不能耦合，否则会增加后期接口的维护成本，考虑使用自定义注解+aop；

　　　2、锁的实现方式有很多，根据我们不同的场景和条件有不同的选择，因此加锁和解锁需要进行抽象，aop中只依赖锁的接口；

　　   3、加锁时，我们需要生成key，用来区分是不是同一个请求，这里key的生成比较关键，不同的业务场景key的生成差别很大，我的想法是将这部分key生成逻辑抽象化，定义成接口，后面根据接口入参情况自己实现,当然也可以自己约定规则，通过反射去拼接；　

实现步骤：

1 自定义注解：

/**
 * 锁注解 标记需要加锁的接口
 * @author XuZhangxing
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LockMask {
    // 锁超时释放时间
    long expireSecond() default 10;

    // 锁key的前缀
    LockKeyPrefix lockKeyPre() default LockKeyPrefix.WMD;

    // 方法参数位置默认是0 第一个
    int index() default 0;

    // el表达式 可以用来解析key
    String el() default "";

}

2 锁对象dto

@Data
public final class LockParam {
    // 锁的key
    private String key;
    // 针对一些特殊场景用
    private String val;
    // 超时时间 单位为秒
    private long expireSecond;
    // 加锁是否成功，用来在finally里面释放锁用
    private Boolean success = Boolean.FALSE;

    public LockParam(String key, long expireSecond) {
        this.key = key;
        this.expireSecond = expireSecond;
    }

    public LockParam() {
    }

    @Override
    public String toString() {
        return JsonUtil.obj2String(this);
    }
}

/**
 * 锁key前缀
 *  标记哪个业务系统
 *
 * @author XuZhangxing
 */
public enum LockKeyPrefix {
    WMD
}

3 key生成抽象接口

/**
 * 

 * key生成 为了简化操作，直接由调用方去实现key的生成
 *
 * @author XuZhangxing
 */
@FunctionalInterface
public interface KeyGenerate {

    // 给key使用的 list 支持粒度更细的锁
    List<String> generate();
}

4 实现的aop

package com.xzx.statistics.redis.lock;

import com.google.common.collect.Lists;
import org.aspectj.lang.ProceedingJoinPoint;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 锁切面
 *
 * @author XuZhangxing
 */
@Aspect
@Component
@Order(1)
public final class LockAspect {

    private final LockService lockService;

    @Autowired(required = false)
    public LockAspect(LockService lockService) {
        this.lockService = lockService;
    }

    // 锁的目标对象
    @Pointcut("@annotation(com.xzx.statistics.redis.lock.LockMask)")
    public void lockTargetMethod() {
    }

    @Around("lockTargetMethod()")
    public Object doLock(ProceedingJoinPoint joinPoint) throws Throwable {

        // 获取到方法签名
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();

        // 获取方法目标方法名称
        Method targetMethod = methodSignature.getMethod();

        // 获取实现类方法
        Method targetImplMethod =
                joinPoint.getTarget().getClass().getMethod(targetMethod.getName(), targetMethod.getParameterTypes());

        // 获取到注释对象
        LockMask lockMask = targetImplMethod.getAnnotation(LockMask.class);

        // 获取到目标对象
        Object targetObj = joinPoint.getArgs()[lockMask.index()];

        if (targetObj == null) {
            return joinPoint.proceed();
        }

        // 这里处理两种情况 一种基本数据类型的数据 二实现了KeyGenerate的对象，其他的都不处理
        List<LockParam> lockParamList = getLockKeyList(targetObj, lockMask);

        if (lockParamList.size() < 1) {
            return joinPoint.proceed();
        }
        // 加上分布式锁
        lockService.lock(lockParamList);
        try {
            // 正常业务逻辑 这里可以考虑启动一个异步线程来给当前的锁续期
            // 我觉得这样处理不太合理，不如直接将锁超时时间延长一些，有可能这个方法执行一直阻塞，锁无法释放
            return joinPoint.proceed();
        } finally {
            // 释放锁
            lockService.unLock(lockParamList);

        }
    }

    // 抽取锁的key
    private List<LockParam> getLockKeyList(Object target, LockMask lockMask) {
        String el = lockMask.el();
        if (el.trim().length() > 0) {
            // 适配el 表达式 暂时不支持
            throw new RuntimeException("function not supposed");
        }
        return getLockParams(target, lockMask);
    }

    // 递归遍历锁key
    private List<LockParam> getLockParams(Object target, LockMask lockMask) {
        LockKeyPrefix lockKeyPrefix = lockMask.lockKeyPre();
        long expireSecond = lockMask.expireSecond();
        if (target == null || target.getClass().isPrimitive()
                || target.getClass().isAssignableFrom(String.class)) {
            return Lists.newArrayList(new LockParam(lockKeyPrefix + ":" + target, expireSecond));
        }
        if (target instanceof KeyGenerate) {
            KeyGenerate keyGenerate = (KeyGenerate) target;
            // 注意对key去重
            List<String> keyList = keyGenerate.generate().stream().distinct().collect(Collectors.toList());
            return keyList.stream().map(key -> new LockParam(lockKeyPrefix + ":" + key, expireSecond))
                    .collect(Collectors.toList());
        }
        List<LockParam> result = Lists.newArrayList();
        if (target.getClass().isArray()) {
            Object[] arrayObj = (Object[]) target;
            Arrays.stream(arrayObj).filter(Objects::nonNull)
                    .forEach(obj -> result.addAll(getLockParams(obj, lockMask)));
        } else if (Iterable.class.isAssignableFrom(target.getClass())) {
            Iterable<?> iterable = (Iterable<?>) target;
            iterable.forEach(it -> result.addAll(getLockParams(it, lockMask)));

        }
        return result;
    }

}

总结：

1  锁的实现方式有多种，比如可以使用数据库、redis、zookeeper 等

2 入参是list<String> 这种类型 或list<基本数据类型包装类>，也能适配，可以直接对整个list 加锁

3 最佳实践：建议将方法入参定义成对象，该对象实现 KeyGenerate 接口 ，这样复杂的入参也能由自己掌握key的生成规则，缺点是侵入性强，需要修改请求入参的dto