用MySQL实现一个分布式锁

更新时间:2019-11-19 09:28:44点击次数:245次
介绍
在分布式系统中,分布锁是一个最基础的工具类。例如,部署了2个有付款功能的微服务中,用户有可能对一个订单发起2次付款操作,而这2次请求可能被发到2个服务中,所以必须得用分布式锁防止重复提交,获取到锁的服务正常进行付款操作,获取不到锁的服务提示重复操作。

我司封装了大量的基础工具类,当我们想使用分布式锁的时候只要做3件事情

1.在数据库中建globallocktable表
2.引入相应的jar包
3.在代码中写上@Autowired GlobalLockComponent globalLockComponent即可使用这个组件

看完这篇文章你也可以用springboot-starter的方式实现一个同样的功能。但我们不是用这个方式来实现的,另开一篇文章分析我们是怎么实现的。

这篇文章先分析一下MySQL分布式的实现

建表
CREATE TABLE `globallocktable` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `lockKey` varchar(60) NOT NULL COMMENT '锁名称',
  `createTime` datetime NOT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `lockKey` (`lockKey`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='全局锁';

让别人使用的组件
@Component
public class GlobalLockComponent {
  
  @Resource
  GlobalLockTableDAO globalLockDAO;
  
  /**
   * 尝试获得锁,成功为true,失败为false
   */
  public boolean tryLock(String key) {
    return GlobalLockUtil.tryLock(this.globalLockDAO, key);
  }
  
  /**
   * 如果已经有其他程序占用该锁,并且超过timeoutMs(毫秒)时间,就强制清除这个锁占用
   * 即根据key先删除记录,再添加记录
   */
  public boolean tryLockWithClear(String key, Long timeoutMs) {
    return GlobalLockUtil.tryLockWithClear(this.globalLockDAO, key, timeoutMs);
  }

  /**
   * 释放锁,根据key删除记录
   */
  public void releasLock(String key) {
    GlobalLockUtil.releasLock(this.globalLockDAO, key);
  }

}

锁对象定义如下

public class GlobalLockTable {

  private Integer id;
  private String lockKey;
  private Date createTime;
  // 省略get和set方法
}

GlobalLockTableDAO定义如下

public interface GlobalLockTableDAO {

  int deleteByPrimaryKey(Integer id);
  
  int deleteByLockKey(String lockKey);

  GlobalLockTable selectByLockKey(String key);

  int insertSelectiveWithTest(GlobalLockTable record);
}

具体加锁和解锁逻辑
public class GlobalLockUtil {

  private static Logger logger = LoggerFactory.getLogger(GlobalLockUtil.class);

  private static GlobalLockTable tryLockInternal(GlobalLockTableDAO lockDAO, String key) {
    GlobalLockTable insert = new GlobalLockTable();
    insert.setCreateTime(new Date());
    insert.setLockKey(key);
    // 注意的地方1
    int count = lockDAO.insertSelectiveWithTest(insert);
    if (count == 0) {
      GlobalLockTable ready = lockDAO.selectByLockKey(key);
      logger.warn("can not lock the key: {}, {}, {}", insert.getLockKey(), ready.getCreateTime(),
          ready.getId());
      return ready;
    }
    logger.info("yes got the lock by key: {}", insert.getId(), insert.getLockKey());
    return null;
  }

  /** 超时清除锁占用,并重新加锁 **/
  public static boolean tryLockWithClear(GlobalLockTableDAO lockDAO, String key, Long timeoutMs) {
    GlobalLockTable lock = tryLockInternal(lockDAO, key);
    if (lock == null) return true;
    if (System.currentTimeMillis() - lock.getCreateTime().getTime() <= timeoutMs) {
      logger.warn("sorry, can not get the key. : {}, {}, {}", key, lock.getId(), lock.getCreateTime());
      return false;
    }
    logger.warn("the key already timeout wthin : {}, {}, will clear", key, timeoutMs);
    // 注意的地方2
    int count = lockDAO.deleteByPrimaryKey(lock.getId());
    if (count == 0) {
      logger.warn("sorry, the key already preemptived by others: {}, {}", lock.getId(), lock.getLockKey());
      return false;
    }
    lock = tryLockInternal(lockDAO, key);
    return lock != null ? false : true;
  }
  
  /** 加锁 **/
  public static boolean tryLock(GlobalLockTableDAO lockDAO, String key) {
    return tryLockInternal(lockDAO, key) == null ? true : false;
  }
  
  /** 解锁 **/
  public static void releasLock(GlobalLockTableDAO lockDAO, String key) {
    lockDAO.deleteByLockKey(key);
  }
}

这个工具类有2个特别有意思的地方,先看注意的地方2(上面代码中标识了)

1.为了避免锁长时间不释放,用Redis实现的话可以设置锁超时时间,超时自动释放(后面会写用Redis实现分布式锁)用MySQL实现的话可以先删除后添加。可以看到删除的时候使用id删的,不是用name删的。为啥呢?先自己想一下

因为如果是通过name删的话,有可能别人删了这个锁后,又通过name加了锁,还没到超时时间,结果你却根据name删除了。通过id删的话,当返回的id=0时,说明别人已经重新加锁了,你需要重新获取。

2.GlobalLockTable 对象dao层的其他方法都见名知意,来看一个这个方法。即代码中的注意点1
可以看到每次尝试加锁的时候,并不是先select,而是直接insertSelectiveWithTest,这样就少了一个查询时间,提高了效率

insertSelectiveWithTest的作用是当lockKey存在时不进行插入操作,返回0。当lockKey不存在时进行插入操作,返回1

<insert id="insertSelectiveWithTest" useGeneratedKeys="true" keyProperty="id" parameterType="com.javashitang.middleware.lock.mysql.pojo.GlobalLockTable">
  insert into `globallocktable` (`id`,
  `lockKey`, `createTime` )
   select #{id,jdbcType=INTEGER}, #{lockKey,jdbcType=VARCHAR}, #{createTime,jdbcType=TIMESTAMP}
   from dual where not exists
    (select 1 from globallocktable where lockKey = #{lockKey,jdbcType=VARCHAR})
</insert>

使用
当我们想使用时,就只写业务逻辑就行了,非常方便

if (!globalLockComponent.tryLock(name)) {
  // 没有获取到锁返回
  return;
}
try {
  // 这里写业务逻辑
} catch (Exception e) {
} finally {
  globalLockComponent.releasLock(name)
}

本站文章版权归原作者及原出处所有 。内容为作者个人观点, 并不代表本站赞同其观点和对其真实性负责,本站只提供参考并不构成任何投资及应用建议。本站是一个个人学习交流的平台,网站上部分文章为转载,并不用于任何商业目的,我们已经尽可能的对作者和来源进行了通告,但是能力有限或疏忽,造成漏登,请及时联系我们,我们将根据著作权人的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。

  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息