使用MySQL实现一个分布式锁

介绍

在分布式系统中，分布锁是一个最基础的工具类。例如，部署了2个有付款功能的微服务中，用户有可能对一个订单发起2次付款操作，而这2次请求可能被发到2个服务中，所以必须得用分布式锁防止重复提交，获取到锁的服务正常进行付款操作，获取不到锁的服务提示重复操作。

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

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

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

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

建表

 

?

1 2 3 4 5 6 7

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= '全局锁' ;

让别人使用的组件

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

@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 );   } }

锁对象定义如下

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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); }

具体加锁和解锁逻辑

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

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

?

1 2 3 4 5 6 7

< 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 >

使用

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

?

1 2 3 4 5 6 7 8 9

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

总结

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

原文链接：https://blog.csdn.net/zzti_erlie/article/details/102769447