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