使用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=TIMESТAMP}

  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实现一个分布式锁，希望对大家有所帮助！