使用复述,实现分布式锁及其优化

布尔tryLock(字符串键,int lockSeconds){
如果(SETNX键“1”= = 1){
关键lockSeconds到期
还真
其他} {
返回假
}
}
布尔解锁(String键){
DEL键
}

C1 DEL键C1 SETNX关键< expireTime >C2 DEL键C2 SETNX关键< expireTime >

公共 类 RedisLock {
私人 静态 最后日志记录器= LoggerFactory.getLogger(RedisLock.class);
私人 最后StringRedisTemplate StringRedisTemplate;
私人 最后 字节[]lockKey;
公共 RedisLock(StringRedisTemplate StringRedisTemplate,字符串lockKey) {
这。 stringRedisTemplate = stringRedisTemplate;
这。 lockKey = lockKey.getBytes();
}
私人 布尔 tryLock(RedisConnection康涅狄格州,intlockSeconds) 抛出异常{
长nowTime = System.currentTimeMillis();
长expireTime = nowTime + lockSeconds *1000年+1000年;/ /容忍不同服务器时间有1秒内的误差
如果(conn.setNX(lockKey longToBytes(expireTime))){
conn.expire(lockKey lockSeconds);
返回 真正的;
}其他的{
字节[]oldValue = conn.get(lockKey);
如果(oldValue ! =零& & bytesToLong(oldValue)< nowTime){
/ /这个锁已经过期了,可以获得它
/ / PS:如果setNX和到期之间客户端发生崩溃,可能会出现这样的情况
字节[]oldValue2 = conn.getSet(lockKey longToBytes(expireTime));
如果(数组。 =(oldValue oldValue2)){
/ /获得了锁
conn.expire(lockKey lockSeconds);
返回 真正的;
}其他的{
/ /被别人抢占了锁(此时已经修改了lockKey中的值,不过误差很小可以忽略)
返回 假;
}
}
}
返回 假;
}
/ * *
*尝试获得锁,成功返回真,如果失败或异常立即返回错误的
*
*@paramlockSeconds加锁的时间(秒),超过这个时间后锁会自动释放
* /
公共 布尔 tryLock(最后 intlockSeconds) {
返回stringRedisTemplate.execute(新RedisCallback <布尔>(){
@Override
公共布尔doInRedis(RedisConnection康涅狄格州) 抛出DataAccessException{
试一试{
返回tryLock(康涅狄格州,lockSeconds);
}抓(异常e){
logger.error(“tryLock错误”,e);
返回 假;
}
}
});
}
/ * *
*轮询的方式去获得锁,成功返回真,超过轮询次数或异常返回错误的
*
*@paramlockSeconds加锁的时间(秒),超过这个时间后锁会自动释放
*@paramtryIntervalMillis轮询的时间间隔(毫秒)
*@parammaxTryCount最大的轮询次数
* /
公共 布尔 tryLock(最后 intlockSeconds,最后 长tryIntervalMillis,最后 intmaxTryCount) {
返回stringRedisTemplate.execute(新RedisCallback <布尔>(){
@Override
公共布尔doInRedis(RedisConnection康涅狄格州) 抛出DataAccessException{
inttryCount =0;
而(真正的){
如果(+ + tryCount > = maxTryCount){
/ /获取锁超时
返回 假;
}
试一试{
如果(tryLock(康涅狄格州,lockSeconds)){
返回 真正的;
}
}抓(异常e){
logger.error(“tryLock错误”,e);
返回 假;
}
试一试{
thread . sleep(tryIntervalMillis);
}抓(InterruptedException e){
logger.error(“tryLock打断了”,e);
返回 假;
}
}
}
});
}
/ * *
*如果加锁后的操作比较耗时,调用方其实可以在解锁前根据时间判断下锁是否已经过期
*如果已经过期可以不用调用,减少一次请求
* /
公共 无效 解锁() {
stringRedisTemplate.delete(新字符串(lockKey));
}
公共 字节[]longToBytes(长值){
ByteBuffer缓冲= ByteBuffer.allocate(长。 尺寸/ Byte.SIZE);
buffer.putLong(价值);
返回buffer.array();
}
公共 长 bytesToLong(字节[]字节) {
如果(字节。 长度! =长。 尺寸/ Byte.SIZE){
扔 新IllegalArgumentException(“错误的字节长度!”);
}
返回ByteBuffer.wrap(字节).getLong();
}
}

如果(redis.call(“setnx”、钥匙(1],ARGV[1)= =1)然后
redis.call(“过期”、钥匙(1),当时(ARGV[2)))
返回 真正的
其他的
返回 假
结束

公共 类 RedisLock {
私人 静态 最后日志记录器= LoggerFactory.getLogger(RedisLock.class);
私人 最后StringRedisTemplate StringRedisTemplate;
私人 最后字符串lockKey;
私人 最后<字符串>键列表;
/ * *
*使用脚本在复述,服务器执行这个逻辑可以在一定程度上保证此操作的原子性
*(即不会发生客户端在执行setNX和到期命令之间,发生崩溃或失去与服务器的连接导致过期没有得到执行,发生永久死锁)
* < p >
*除非脚本在复述,服务器执行时复述,服务器发生崩溃,不过此种情况锁也会失效
* /
私人 静态 最后RedisScript <布尔> SETNX_AND_EXPIRE_SCRIPT;
静态{
StringBuilder某人=新StringBuilder();
sb.append(“如果(复述。 调用(setnx,键[1],ARGV[1])= = 1),那么\ n ");
sb.append(“\ tredis。 调用(“过期”,键[1],当时(ARGV[2]))\ n”);
sb.append(“\ treturn真的\ n”);
sb.append(“\ n”);
sb.append(“\ treturn假\ n”);
sb.append(“结束”);
SETNX_AND_EXPIRE_SCRIPT =新RedisScriptImpl <布尔>(sb.toString(),Boolean.class);
}
公共 RedisLock(StringRedisTemplate StringRedisTemplate,字符串lockKey) {
这。 stringRedisTemplate = stringRedisTemplate;
这。 lockKey = lockKey;
这。 键= Collections.singletonList(lockKey);
}
私人 布尔 doTryLock(intlockSeconds) 抛出异常{
返回stringRedisTemplate。 execute(SETNX_AND_EXPIRE_SCRIPT、钥匙、“1”String.valueOf(lockSeconds));
}
/ * *
*尝试获得锁,成功返回真,如果失败立即返回错误的
*
*@paramlockSeconds加锁的时间(秒),超过这个时间后锁会自动释放
* /
公共 布尔 tryLock(intlockSeconds) {
试一试{
返回doTryLock(lockSeconds);
}抓(异常e){
logger.error(“tryLock错误”,e);
返回 假;
}
}
/ * *
*轮询的方式去获得锁,成功返回真,超过轮询次数或异常返回错误的
*
*@paramlockSeconds加锁的时间(秒),超过这个时间后锁会自动释放
*@paramtryIntervalMillis轮询的时间间隔(毫秒)
*@parammaxTryCount最大的轮询次数
* /
公共 布尔 tryLock(最后 intlockSeconds,最后 长tryIntervalMillis,最后 intmaxTryCount) {
inttryCount =0;
而(真正的){
如果(+ + tryCount > = maxTryCount){
/ /获取锁超时
返回 假;
}
试一试{
如果(doTryLock(lockSeconds)){
返回 真正的;
}
}抓(异常e){
logger.error(“tryLock错误”,e);
返回 假;
}
试一试{
thread . sleep(tryIntervalMillis);
}抓(InterruptedException e){
logger.error(“tryLock打断了”,e);
返回 假;
}
}
}
/ * *
*如果加锁后的操作比较耗时,调用方其实可以在解锁前根据时间判断下锁是否已经过期
*如果已经过期可以不用调用,减少一次请求
* /
公共 无效 解锁() {
stringRedisTemplate.delete(lockKey);
}
私人 静态 类 RedisScriptImpl<T>实现了 RedisScript<T>{
私人 最后字符串脚本;
私人 最后字符串sha1;
私人 最后类< T > resultType;
公共 RedisScriptImpl(字符串脚本,类< T > resultType) {
这。 脚本=脚本;
这。 sha1 = DigestUtils.sha1DigestAsHex(脚本);
这。 resultType = resultType;
}
@Override
公共字符串getSha1() {
返回sha1;
}
@Override
公共类< T >getResultType() {
返回resultType;
}
@Override
公共字符串getScriptAsString() {
返回脚本;
}
}
}

进口java.util.Collections;
进口java.util.UUID;
进口org.slf4j.Logger;
进口org.slf4j.LoggerFactory;
进口org.springframework.data.redis.core.StringRedisTemplate;
进口org.springframework.data.redis.core.script.DigestUtils;
进口org.springframework.data.redis.core.script.RedisScript;
/ * *
*创建在2017年10/24
*复述,实现的分布式锁(不可重入)
*此对象非线程安全,使用时务必注意
* /
公共 类 RedisLock {
私人 静态 最后日志记录器= LoggerFactory.getLogger(RedisLock.class);
私人 最后StringRedisTemplate StringRedisTemplate;
私人 最后字符串lockKey;
私人 最后字符串lockValue;
私人 布尔锁=假;
/ * *
*使用脚本在复述,服务器执行这个逻辑可以在一定程度上保证此操作的原子性
*(即不会发生客户端在执行setNX和到期命令之间,发生崩溃或失去与服务器的连接导致过期没有得到执行,发生永久死锁)
* < p >
*除非脚本在复述,服务器执行时复述,服务器发生崩溃,不过此种情况锁也会失效
* /
私人 静态 最后RedisScript <布尔> SETNX_AND_EXPIRE_SCRIPT;
静态{
StringBuilder某人=新StringBuilder();
sb.append(“如果(复述。 调用(setnx,键[1],ARGV[1])= = 1),那么\ n ");
sb.append(“\ tredis。 调用(“过期”,键[1],当时(ARGV[2]))\ n”);
sb.append(“\ treturn真的\ n”);
sb.append(“\ n”);
sb.append(“\ treturn假\ n”);
sb.append(“结束”);
SETNX_AND_EXPIRE_SCRIPT =新RedisScriptImpl <布尔>(sb.toString(),Boolean.class);
}
私人 静态 最后RedisScript <布尔> DEL_IF_GET_EQUALS;
静态{
StringBuilder某人=新StringBuilder();
sb.append(“如果(复述。 调用(“得到”,键[1])= = ARGV[1])然后\ n”);
sb.append(“\ tredis。 调用(“▽”键[1])\ n”);
sb.append(“\ treturn真的\ n”);
sb.append(“\ n”);
sb.append(“\ treturn假\ n”);
sb.append(“结束”);
DEL_IF_GET_EQUALS =新RedisScriptImpl <布尔>(sb.toString(),Boolean.class);
}
公共 RedisLock(StringRedisTemplate StringRedisTemplate,字符串lockKey) {
这。 stringRedisTemplate = stringRedisTemplate;
这。 lockKey = lockKey;
这。 .toString lockValue = UUID.randomUUID()()+“。”+ System.currentTimeMillis();
}
私人 布尔 doTryLock(intlockSeconds) 抛出异常{
如果(锁){
扔 新IllegalStateException(“已经锁定!”);
}
锁= stringRedisTemplate。 执行(SETNX_AND_EXPIRE_SCRIPT Collections.singletonList(lockKey)lockValue,
String.valueOf(lockSeconds));
返回锁定;
}
/ * *
*尝试获得锁,成功返回真,如果失败立即返回错误的
*
*@paramlockSeconds加锁的时间(秒),超过这个时间后锁会自动释放
* /
公共 布尔 tryLock(intlockSeconds) {
试一试{
返回doTryLock(lockSeconds);
}抓(异常e){
logger.error(“tryLock错误”,e);
返回 假;
}
}
/ * *
*轮询的方式去获得锁,成功返回真,超过轮询次数或异常返回错误的
*
*@paramlockSeconds加锁的时间(秒),超过这个时间后锁会自动释放
*@paramtryIntervalMillis轮询的时间间隔(毫秒)
*@parammaxTryCount最大的轮询次数
* /
公共 布尔 tryLock(最后 intlockSeconds,最后 长tryIntervalMillis,最后 intmaxTryCount) {
inttryCount =0;
而(真正的){
如果(+ + tryCount > = maxTryCount){
/ /获取锁超时
返回 假;
}
试一试{
如果(doTryLock(lockSeconds)){
返回 真正的;
}
}抓(异常e){
logger.error(“tryLock错误”,e);
返回 假;
}
试一试{
thread . sleep(tryIntervalMillis);
}抓(InterruptedException e){
logger.error(“tryLock打断了”,e);
返回 假;
}
}
}
/ * *
*解锁操作
* /
公共 无效 解锁() {
如果(锁){
扔 新IllegalStateException(“没有锁!”);
}
锁=假;
/ /忽略结果
stringRedisTemplate。 执行(DEL_IF_GET_EQUALS Collections.singletonList(lockKey)lockValue);
}
私人 静态 类 RedisScriptImpl<T>实现了 RedisScript<T>{
私人 最后字符串脚本;
私人 最后字符串sha1;
私人 最后类< T > resultType;
公共 RedisScriptImpl(字符串脚本,类< T > resultType) {
这。 脚本=脚本;
这。 sha1 = DigestUtils.sha1DigestAsHex(脚本);
这。 resultType = resultType;
}
@Override
公共字符串getSha1() {
返回sha1;
}
@Override
公共类< T >getResultType() {
返回resultType;
}
@Override
公共字符串getScriptAsString() {
返回脚本;
}
}
}