使用MySQL实现分布式锁

分布式锁开发中经常使用，在项目多节点部署或者微服务项目中，JAVA提供的线程锁已经不能满足安全的需求，需要使用全局的分布式锁来保证安全；分布式锁的实现的方式有很多种，最常见的有zookeeper，Redis，数据库等；zookeeper和redis都需要我们单独部署甚至搭建集群去提高可用性。这对于服务资源本身不够的机器来说更是雪上加霜，不过mysql这种作为一个储存功能应用，我们离不开它，所以用它来实现分布式锁，不需要额外的去维护一个应用，实现起来也比较简单，对并发不高项目而言是一种比较好的实现方式；

• 优点：简单高效可靠
• 缺点：并发性能较低，功能相对来说比较单一

本次演示使用的框架为 SpringBoot+MybatisPlus

1.创建数据库表

这里我的主键并未使用自增，因为解锁时会利用主键去做唯一判断，而且锁在释放的时候会删除数据，并且数据库可能会做集群，使用自增主键意义不大，所以采用了雪花算法实现主键；

CREATE TABLE `lock_info` (
  `id` bigint(20) unsigned NOT NULL,
  `expiration_time` datetime DEFAULT NULL COMMENT '过期时间',
  `status` tinyint(1) DEFAULT NULL COMMENT '锁状态，0，未锁，1，已经上锁',
  `tag` varchar(255) DEFAULT NULL COMMENT '锁的标识，如项目id',
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  KEY `uni_tag` (`tag`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='数据库分布式锁表';

2.代码逻辑

实体对象，id采用雪花算法

@Data
@TableName(value = "lock_info")
public class LockInfo implements Serializable {
    private static final long serialVersionUID = 1L;

    public static final Integer LOCKED_STATUS = 1;
    public static final Integer UNLOCKED_STATUS = 0;

    /**
     * 最大超时时间,超过将删除
     */
    public static final Integer MAX_TIMEOUT_SECONDS = 120;

    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    /**
     * 锁过期时间
     */
    private Date expirationTime;

    /**
     * 锁状态，0，未锁，1，已经上锁
     */
    private Integer status = LOCKED_STATUS;

    /**
     * 锁的标识，如项目id
     */
    private String tag;

    private Date createTime;

    private Date updateTime;
}

锁的数据视图对象

public class LockVo implements Serializable {

    /**
     * 锁的id
     */
    private Long lockId;

    /**
     * 锁过期时间
     */
    private Date expirationTime;

    /**
     * 锁的标识，如项目id
     */
    private final String tag;

    public LockVo(String tag) {
        this.tag = tag;
    }

    public void setLockId(Long lockId) {
        this.lockId = lockId;
    }

    public void setExpirationTime(Date expirationTime) {
        this.expirationTime = expirationTime;
    }

    public Long getLockId() {
        return lockId;
    }

    public Date getExpirationTime() {
        return expirationTime;
    }

    public String getTag() {
        return tag;
    }

    @Override
    public String toString() {
        return "LockVo{" +
                "lockId=" + lockId +
                ", expirationTime=" + expirationTime +
                ", tag='" + tag + '\'' +
                '}';
    }
}

mapper对象

public interface LockInfoMapper extends BaseMapper<LockInfo> {

}

service接口

public interface ILockInfoService extends IService<LockInfo> {

    /**
     * 根据锁标识获取锁信息
     *
     * @param tag 锁标识
     * @return com.chinaunicom.deliver.api.model.eo.LockInfo
     */
    LockInfo findByTag(String tag);

    /**
     * 尝试获取锁
     *
     * @param lockVo         锁的数据信息
     * @param expiredSeconds 锁的过期时间（单位：秒），默认10s
     * @return boolean
     */
    boolean tryLock(LockVo lockVo, Integer expiredSeconds);

    /**
     * 尝试获取锁,默认锁定10秒
     *
     * @param lockVo 锁的数据信息
     * @return boolean
     */
    boolean tryLock(LockVo lockVo);

    /**
     * 释放锁
     *
     * @param lockVo 锁的数据对象
     */
    void unlock(LockVo lockVo);
}

service实现类

@Service
public class LockInfoServiceImpl extends ServiceImpl<LockInfoMapper, LockInfo> implements ILockInfoService {

    private static final Integer DEFAULT_EXPIRED_SECONDS = 10;

    @Autowired
    private PlatformTransactionManager platformTransactionManager;

    @Autowired
    private TransactionDefinition transactionDefinition;

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    @Override
    public boolean tryLock(LockVo lockVo, Integer expiredSeconds) {
        if (lockVo == null || StringUtils.isEmpty(lockVo.getTag())) {
            throw new NullPointerException();
        }

        Date now = new Date();

        LockInfo lock = findByTag(lockVo.getTag());

        TransactionStatus transaction = null;
        try {
            if (Objects.isNull(lock)) {
                transaction = platformTransactionManager.getTransaction(transactionDefinition);
                lock = new LockInfo(lockVo.getTag(), this.getExpiredSeconds(new Date(), expiredSeconds));
                this.save(lock);
                platformTransactionManager.commit(transaction);
                lockVo.setLockId(lock.getId());
                return true;
            } else {
                Date expiredTime = lock.getExpirationTime();
                if (expiredTime.before(now)) {
                    transaction = platformTransactionManager.getTransaction(transactionDefinition);
                    // 如果过期并且超过过期时间120秒之后，将删除锁数据
                    if (expiredTime.before(getExpiredSeconds(expiredTime, LockInfo.MAX_TIMEOUT_SECONDS))) {
                        this.removeById(lock.getId());
                    }
                    lock.setExpirationTime(this.getExpiredSeconds(now, expiredSeconds));
                    lock.setId(null);
                    this.save(lock);
                    platformTransactionManager.commit(transaction);
                    lockVo.setLockId(lock.getId());
                    return true;
                }
            }
        } catch (Exception e) {
            if (transaction != null) {
                platformTransactionManager.rollback(transaction);
            }
        }
        return false;
    }

    @Override
    public boolean tryLock(LockVo lockVo) {
        return this.tryLock(lockVo, DEFAULT_EXPIRED_SECONDS);
    }

    @Override
    @Transactional(rollbackFor = Throwable.class)
    public void unlock(LockVo lockVo) {
        if (lockVo == null || StringUtils.isEmpty(lockVo.getTag()) || lockVo.getLockId() == null) {
            throw new NullPointerException();
        }
        LockInfo info = getById(lockVo.getLockId());
        if (info == null || !lockVo.getTag().equals(info.getTag())) {
            return;
        }
        this.removeById(info.getId());
    }

    private Date getExpiredSeconds(Date date, Integer seconds) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.SECOND, seconds);
        return calendar.getTime();
    }

    @Override
    public LockInfo findByTag(String tag) {
        return this.lambdaQuery().eq(LockInfo::getTag, tag)
                .orderByDesc(LockInfo::getExpirationTime)
                .last("limit 1").one();
    }
}

1.注意事项

@Transactional(propagation = Propagation.NOT_SUPPORTED)

• 可以看到加锁的方法上加了事务注解并且配置传播规则为Propagation.NOT_SUPPORTED（以非事务的方式运行，如果当前存在事务，则挂起当前事务），这样配置是为了使用手动事务，如果不加上该注解，SpringBoot会自动帮我们加入当前事务，这样就没办法手动提交事务；这样会导致在并发时，我们的加锁事务在会等待外部事务一起提交，在默认的隔离级别下面，其他线程的事务是没办法读取未提交的事务，也就是说我们加的锁数据没有保存进数据库，其他线程一样可以加锁，这样就导致加锁失败了；
• 加锁的时候会查询当前锁对象tag在表中过期时间最长的那个数据，避免锁过期没有释放，一个tag对应多个值的问题。并且在解锁的时候需要用主键id和tag对应唯一值，删除了其他加了锁的数据。

什么时候会出现删除其他锁对象的数据：当一个操作执行的时间过长，获取的锁已经过期，此时其他同样需要这个锁的任务是能够获取锁的，那么此时表中相同的tag数据至少是2条以上，如果不使用主键id和tag做唯一标识，那么在释放锁的时候就会把别的任务加的锁一起删除了，导致其他任务释放锁失败！