open-source/spring-lock
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Feature] add for new

Browse Source
This commit is contained in:
binbin.hou
2020-09-10 11:19:54 +08:00
parent 0509780502
commit 3a8c68a19d
17 changed files with 318 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
lock-core/pom.xml Normal file
View File

@@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>lock</artifactId>
<groupId>com.github.houbb</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>lock-redis</artifactId>
<description>The lock depends on redis.</description>
<dependencies>
<!--============================== SELF ==============================-->
<dependency>
<groupId>com.github.houbb</groupId>
<artifactId>lock-api</artifactId>
</dependency>
<!--============================== INTER ==============================-->
<dependency>
<groupId>com.github.houbb</groupId>
<artifactId>id-core</artifactId>
</dependency>
<dependency>
<groupId>com.github.houbb</groupId>
<artifactId>wait</artifactId>
</dependency>
<dependency>
<groupId>com.github.houbb</groupId>
<artifactId>heaven</artifactId>
</dependency>
<!--============================== OTHER ==============================-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
</dependencies>
</project>

71
lock-core/src/main/java/com/github/houbb/lock/redis/bs/LockRedisBs.java Normal file
View File

@@ -0,0 +1,71 @@
package com.github.houbb.lock.redis.bs;
import com.github.houbb.id.api.Id;
import com.github.houbb.id.core.core.Ids;
import com.github.houbb.lock.api.core.ILock;
import com.github.houbb.lock.redis.core.LockRedis;
import com.github.houbb.lock.redis.support.operator.IOperator;
import com.github.houbb.wait.api.IWait;
import com.github.houbb.wait.core.Waits;
/**
* 引导类
* @author binbin.hou
* @since 0.0.1
*/
public final class LockRedisBs {
private LockRedisBs(){}
/**
* 等待实现
* @since 0.0.1
*/
private IWait wait = Waits.threadSleep();
/**
* 等待实现
* @since 0.0.1
*/
private Id id = Ids.uuid32();
/**
* 操作类
* @since 0.0.1
*/
private IOperator operator;
/**
* 新建对象实例
* @return 对象实例
* @since 0.0.1
*/
public static LockRedisBs newInstance() {
return new LockRedisBs();
}
public LockRedisBs wait(IWait wait) {
this.wait = wait;
return this;
}
public LockRedisBs id(Id id) {
this.id = id;
return this;
}
public LockRedisBs operator(IOperator operator) {
this.operator = operator;
return this;
}
/**
* 创建锁
* @return 锁
* @since 0.0.1
*/
public ILock lock() {
return new LockRedis(wait, operator, id);
}
}

56
lock-core/src/main/java/com/github/houbb/lock/redis/constant/LockRedisConst.java Normal file
View File

@@ -0,0 +1,56 @@
package com.github.houbb.lock.redis.constant;
/**
* redis 锁常量
*
* @author binbin.hou
* @since 0.0.1
*/
public final class LockRedisConst {
private LockRedisConst() {
}
/**
* 加锁成功
* @since 0.0.1
*/
public static final String LOCK_SUCCESS = "OK";
/**
* 如果不存在则设置值
* @since 0.0.1
*/
public static final String SET_IF_NOT_EXIST = "NX";
/**
* 设置过期时间
*
* 单位：milliseconds
* @since 0.0.1
*/
public static final String SET_WITH_EXPIRE_TIME = "PX";
/**
* 解锁成功
*
* @since 0.0.1
*/
public static final Long RELEASE_SUCCESS = 1L;
/**
* 默认的失效时间
*
* 暂时定为 30min
* @since 0.0.1
*/
public static final int DEFAULT_EXPIRE_MILLS = 1000 * 60 * 30;
/**
* 默认锁为全局锁
* @since 0.0.1
*/
public static final String DEFAULT_KEY = "GLOBAL";
}

87
lock-core/src/main/java/com/github/houbb/lock/redis/core/AbstractLockRedis.java Normal file
View File

@@ -0,0 +1,87 @@
package com.github.houbb.lock.redis.core;
import com.github.houbb.lock.api.core.ILock;
import com.github.houbb.lock.redis.constant.LockRedisConst;
import com.github.houbb.wait.api.IWait;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
/**
* 抽象实现
* @author binbin.hou
* @since 0.0.1
*/
public abstract class AbstractLockRedis implements ILock {
/**
* 锁等待
* @since 0.0.1
*/
private final IWait wait;
protected AbstractLockRedis(IWait wait) {
this.wait = wait;
}
@Override
public void lock() {
throw new UnsupportedOperationException();
}
@Override
public void lockInterruptibly() throws InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public boolean tryLock() {
return tryLock(LockRedisConst.DEFAULT_KEY);
}
@Override
public void unlock() {
unlock(LockRedisConst.DEFAULT_KEY);
}
@Override
public boolean tryLock(long time, TimeUnit unit, String key) throws InterruptedException {
long startTimeMills = System.currentTimeMillis();
// 一次获取，直接成功
boolean result = this.tryLock(key);
if(result) {
return true;
}
// 时间判断
if(time <= 0) {
return false;
}
long durationMills = unit.toMillis(time);
long endMills = startTimeMills + durationMills;
// 循环等待
while (System.currentTimeMillis() < endMills) {
result = tryLock(key);
if(result) {
return true;
}
// 等待 10ms
wait.wait(TimeUnit.MILLISECONDS, 10);
}
return false;
}
@Override
public synchronized boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return tryLock(time, unit, LockRedisConst.DEFAULT_KEY);
}
@Override
public Condition newCondition() {
throw new UnsupportedOperationException();
}
}

60
lock-core/src/main/java/com/github/houbb/lock/redis/core/LockRedis.java Normal file
View File

@@ -0,0 +1,60 @@
package com.github.houbb.lock.redis.core;
import com.github.houbb.heaven.util.lang.StringUtil;
import com.github.houbb.id.api.Id;
import com.github.houbb.id.core.util.IdThreadLocalHelper;
import com.github.houbb.lock.redis.constant.LockRedisConst;
import com.github.houbb.lock.redis.exception.LockRedisException;
import com.github.houbb.lock.redis.support.operator.IOperator;
import com.github.houbb.wait.api.IWait;
/**
* 这里是基于 redis 实现
*
* 实际上也可以基于 zk/数据库等实现。
*
* @author binbin.hou
* @since 0.0.1
*/
public class LockRedis extends AbstractLockRedis {
/**
* redis 操作实现
* @since 0.0.1
*/
private final IOperator redisOperator;
/**
* 主键标识
* @since 0.0.1
*/
private final Id id;
public LockRedis(IWait wait, IOperator redisOperator, Id id) {
super(wait);
this.redisOperator = redisOperator;
this.id = id;
}
@Override
public boolean tryLock(String key) {
final String requestId = id.id();
IdThreadLocalHelper.put(requestId);
return redisOperator.lock(key, requestId, LockRedisConst.DEFAULT_EXPIRE_MILLS);
}
@Override
public void unlock(String key) {
final String requestId = IdThreadLocalHelper.get();
if(StringUtil.isEmpty(requestId)) {
String threadName = Thread.currentThread().getName();
throw new LockRedisException("Thread " + threadName +" not contains requestId");
}
boolean unlock = redisOperator.unlock(key, requestId);
if(!unlock) {
throw new LockRedisException("Unlock key " + key + " result is failed!");
}
}
}

27
lock-core/src/main/java/com/github/houbb/lock/redis/exception/LockRedisException.java Normal file
View File

@@ -0,0 +1,27 @@
package com.github.houbb.lock.redis.exception;
/**
* @author binbin.hou
* @since 0.0.1
*/
public class LockRedisException extends RuntimeException {
public LockRedisException() {
}
public LockRedisException(String message) {
super(message);
}
public LockRedisException(String message, Throwable cause) {
super(message, cause);
}
public LockRedisException(Throwable cause) {
super(cause);
}
public LockRedisException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}

1
lock-core/src/main/java/com/github/houbb/lock/redis/package-info.java Normal file
View File

@@ -0,0 +1 @@
package com.github.houbb.lock.redis;

30
lock-core/src/main/java/com/github/houbb/lock/redis/support/operator/IOperator.java Normal file
View File

@@ -0,0 +1,30 @@
package com.github.houbb.lock.redis.support.operator;
/**
* Redis 客户端
* @author binbin.hou
* @since 0.0.1
*/
public interface IOperator {
/**
* 尝试获取分布式锁
*
* @param lockKey 锁
* @param requestId 请求标识
* @param expireTimeMills 超期时间
* @return 是否获取成功
* @since 0.0.1
*/
boolean lock(String lockKey, String requestId, int expireTimeMills);
/**
* 解锁
* @param lockKey 锁 key
* @param requestId 请求标识
* @return 结果
* @since 0.0.1
*/
boolean unlock(String lockKey, String requestId);
}

63
lock-core/src/main/java/com/github/houbb/lock/redis/support/operator/impl/JedisOperator.java Normal file
View File

@@ -0,0 +1,63 @@
package com.github.houbb.lock.redis.support.operator.impl;
import com.github.houbb.lock.redis.constant.LockRedisConst;
import com.github.houbb.lock.redis.support.operator.IOperator;
import redis.clients.jedis.Jedis;
import java.util.Collections;
/**
* Redis 客户端
* @author binbin.hou
* @since 0.0.1
*/
public class JedisOperator implements IOperator {
/**
* jedis 客户端
* @since 0.0.1
*/
private final Jedis jedis;
public JedisOperator(Jedis jedis) {
this.jedis = jedis;
}
/**
* 尝试获取分布式锁
*
* expireTimeMills 保证当前进程挂掉，也能释放锁
*
* requestId 保证解锁的是当前进程（锁的持有者）
*
* @param lockKey 锁
* @param requestId 请求标识
* @param expireTimeMills 超期时间
* @return 是否获取成功
* @since 0.0.1
*/
@Override
public boolean lock(String lockKey, String requestId, int expireTimeMills) {
String result = jedis.set(lockKey, requestId, LockRedisConst.SET_IF_NOT_EXIST, LockRedisConst.SET_WITH_EXPIRE_TIME, expireTimeMills);
return LockRedisConst.LOCK_SUCCESS.equals(result);
}
/**
* 解锁
*
* （1）使用 requestId，保证为当前锁的持有者
* （2）使用 lua 脚本，保证执行的原子性。
*
* @param lockKey 锁 key
* @param requestId 请求标识
* @return 结果
* @since 0.0.1
*/
@Override
public boolean unlock(String lockKey, String requestId) {
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
return LockRedisConst.RELEASE_SUCCESS.equals(result);
}
}

1
lock-core/src/main/java/com/github/houbb/lock/redis/support/package-info.java Normal file
View File

@@ -0,0 +1 @@
package com.github.houbb.lock.redis.support;