java多线程事务加锁引发bug用户重复注册解决分析

/**
 * 根据用户手机号进行注册操作
 */
// 启动@Transactional事务注解
@Transactional(rollbackFor = Exception.class)
public boolean userRegister(LoginReqBody body, BaseReqHeader header, BaseResp<BaseRespHeader, LoginRespBody> resp) {
    RedisLock redisLock = redisCache.getRedisLock(RedisNameEnum.USER_REGISTER_LOCK.get(""), 10);
    boolean lock;
    try {
        lock = redisLock.lock();
        // 使用redis分布式锁
        if (lock) {
            // 查询数据库该用户手机号是否插入成功，已存在则退出操作
            MemberDO member = mapper.findByMobile(body.getAccount(), body.getRegRes());
            if (Objects.nonNull(member)) {
                resp.setResultFail(ReturnCodeEnum.USER_EXIST);
                return false;
            }
            // 执行用户注册操作，包含插入用户表、订单表、是否被邀请
            ...
        }
    } catch (Exception e) {
        log.error("用户注册失败：", e);
        throw new Exception("用户注册失败");
    } finally {
        redisLock.unLock();
    }
    // 添加注册日志，上报到数据分析平台...
    return true;
}

@Autowired
private PlatformTransactionManager platformTransactionManager;
@Autowired
private TransactionDefinition transactionDefinition;
private boolean userRegister(LoginReqBody body, BaseReqHeader header, BaseResp<BaseRespHeader, LoginRespBody> resp) {
    RedisLock redisLock = redisCache.getRedisLock(RedisNameEnum.USER_REGISTER_LOCK.get(""), 10);
    boolean lock;
    TransactionStatus transaction = null;
    try {
        lock = redisLock.lock();
        // 使用redis分布式锁
        if (lock) {
            // 查询数据库该用户手机号是否插入成功，已存在则退出操作
            MemberDO member = mapper.findByMobile(body.getAccount(), body.getRegRes());
            if (Objects.nonNull(member)) {
                resp.setResultFail(ReturnCodeEnum.USER_EXIST);
                return false;
            }
            // 手动开启事务
            transaction = platformTransactionManager.getTransaction(transactionDefinition);
            // 执行用户注册操作，包含插入用户表、订单表、是否被邀请
            ...
            // 手动提交事务
            platformTransactionManager.commit(transaction);
            ...
        }
    } catch (Exception e) {
        log.error("用户注册失败：", e);
        if (transaction != null) {
            platformTransactionManager.rollback(transaction);
        }
        return false;
    } finally {
        redisLock.unLock();
    }
    // 添加注册日志，上报到数据分析平台...
    return true;
}

/**
 * 限流枚举
 */
public enum LimitType {
    // 默认
    CUSTOMER,
    //  by ip addr
    IP
}
/**
 * 自定义接口限流
 *
 * @author jacky
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Limit {
    boolean useAccount() default true;
    String name() default "";
    String key() default "";
    String prefix() default "";
    int period();
    int count();
    LimitType limitType() default LimitType.CUSTOMER;
}
/**
 * 限制器切面
 */
@Slf4j
@Aspect
@Component
public class LimitAspect {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Pointcut("@annotation(com.dogame.dragon.sparrow.framework.common.annotation.Limit)")
    public void pointcut() {
    }
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        ServletRequestAttributes attrs = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attrs.getRequest();
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method signatureMethod = signature.getMethod();
        Limit limit = signatureMethod.getAnnotation(Limit.class);
        boolean useAccount = limit.useAccount();
        LimitType limitType = limit.limitType();
        String key = limit.key();
        if (StringUtils.isEmpty(key)) {
            if (limitType == LimitType.IP) {
                key = IpUtils.getIpAddress(request);
            } else {
                key = signatureMethod.getName();
            }
        }
        if (useAccount) {
            LoginMember loginMember = LocalContext.getLoginMember();
            if (loginMember != null) {
                key = key + "_" + loginMember.getAccount();
            }
        }
        String join = StringUtils.join(limit.prefix(), key, "_", request.getRequestURI().replaceAll("/", "_"));
        List<String> strings = Collections.singletonList(join);
        String luaScript = buildLuaScript();
        RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        Long count = stringRedisTemplate.execute(redisScript, strings, limit.count() + "", limit.period() + "");
        if (null != count && count.intValue() <= limit.count()) {
            log.info("第{}次访问key为 {}，描述为 [{}] 的接口", count, strings, limit.name());
            return joinPoint.proceed();
        } else {
            throw new DragonSparrowException("短时间内访问次数受限制");
        }
    }
    /**
     * 限流脚本
     */
    private String buildLuaScript() {
        return "local c" +
                "\nc = redis.call('get',KEYS[1])" +
                "\nif c and tonumber(c) > tonumber(ARGV[1]) then" +
                "\nreturn c;" +
                "\nend" +
                "\nc = redis.call('incr',KEYS[1])" +
                "\nif tonumber(c) == 1 then" +
                "\nredis.call('expire',KEYS[1],ARGV[2])" +
                "\nend" +
                "\nreturn c;";
    }
}