使用MySQL实现一个分布式锁

介绍

在分布式系统中，分布锁是一个最基础的工具类。例如，部署了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)

总结

以上所述是小编给大家介绍的使用mysql实现一个分布式锁，希望对大家有所帮助！