共計 6093 個字符，預計需要花費 16 分鐘才能閱讀完成。
本篇內容介紹了“怎么理解 Redis 中的分布式鎖”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓丸趣 TV 小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！
Redis 分布式鎖
大家項目中都會使用到分布式鎖把，通常用來做數據的有序操作場景，比如一筆訂單退款（如果可以退多次的情況）。或者用戶多端下單。【相關推薦：Redis 視頻教程】
Maven 依賴
我主要是基于 Spring-Boot 2.1.2 + Jedis 進行實現
?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
modelVersion 4.0.0 /modelVersion
parent
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-parent /artifactId
version 2.1.2.RELEASE /version
/parent
groupId cn.edu.cqvie /groupId
artifactId redis-lock /artifactId
version 1.0-SNAPSHOT /version
properties
project.build.sourceEncoding UTF-8 /project.build.sourceEncoding
java.version 1.8 /java.version
redis.version 2.9.0 /redis.version
spring-test.version 5.0.7 /spring-test.version
/properties
dependencies
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-autoconfigure /artifactId
/dependency
dependency
groupId org.springframework.data /groupId
artifactId spring-data-redis /artifactId
/dependency
dependency
groupId redis.clients /groupId
artifactId jedis /artifactId
version ${redis.version} /version
/dependency
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-logging /artifactId
/dependency
dependency
groupId org.slf4j /groupId
artifactId log4j-over-slf4j /artifactId
/dependency
dependency
groupId org.springframework.boot /groupId
artifactId spring-boot-starter-test /artifactId
scope test /scope
/dependency
/dependencies
build
plugins
plugin
groupId org.springframework.boot /groupId
artifactId spring-boot-maven-plugin /artifactId
/plugin
/plugins
/build
/project配置文件
application.properties 配置文件內容如下：
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.timeout=30000
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.min-idle=2
spring.redis.jedis.pool.max-idle=4
logging.level.root=INFO接口定義
接口定義，對于鎖我們核心其實就連個方法 lock 和 unlock.
public interface RedisLock {
long TIMEOUT_MILLIS = 30000;
int RETRY_MILLIS = 30000;
long SLEEP_MILLIS = 10;
boolean tryLock(String key);
boolean lock(String key);
boolean lock(String key, long expire);
boolean lock(String key, long expire, long retryTimes);
boolean unlock(String key);
}分布式鎖實現
我的實現方式是通過 setnx 方式實現了，如果存在 tryLock 邏輯的話，會通過 自旋 的方式重試
// AbstractRedisLock.java 抽象類
public abstract class AbstractRedisLock implements RedisLock {
@Override
public boolean lock(String key) { return lock(key, TIMEOUT_MILLIS);
}
@Override
public boolean lock(String key, long expire) { return lock(key, TIMEOUT_MILLIS, RETRY_MILLIS);
}
// 具體實現
@Component
public class RedisLockImpl extends AbstractRedisLock { private Logger logger = LoggerFactory.getLogger(getClass());
@Autowired
private RedisTemplate String, String redisTemplate;
private ThreadLocal String threadLocal = new ThreadLocal String
private static final String UNLOCK_LUA;
static { StringBuilder sb = new StringBuilder();
sb.append(if redis.call(\ get\ ,KEYS[1]) == ARGV[1]
sb.append( then
sb.append( return redis.call(\ del\ ,KEYS[1])
sb.append( else
sb.append( return 0
sb.append( end
UNLOCK_LUA = sb.toString();
}
@Override
public boolean tryLock(String key) { return tryLock(key, TIMEOUT_MILLIS);
}
public boolean tryLock(String key, long expire) {
try { return !StringUtils.isEmpty(redisTemplate.execute((RedisCallback String) connection - { JedisCommands commands = (JedisCommands) connection.getNativeConnection();
String uuid = UUID.randomUUID().toString();
threadLocal.set(uuid);
return commands.set(key, uuid, NX , PX , expire);
}));
} catch (Throwable e) { logger.error( set redis occurred an exception , e);
}
return false;
}
@Override
public boolean lock(String key, long expire, long retryTimes) { boolean result = tryLock(key, expire);
while (!result retryTimes-- 0) {
try { logger.debug( lock failed, retrying...{} , retryTimes);
Thread.sleep(SLEEP_MILLIS);
} catch (InterruptedException e) {
return false;
}
result = tryLock(key, expire);
}
return result;
}
@Override
public boolean unlock(String key) {
try { List String keys = Collections.singletonList(key);
List String args = Collections.singletonList(threadLocal.get());
Long result = redisTemplate.execute((RedisCallback Long) connection - { Object nativeConnection = connection.getNativeConnection();
if (nativeConnection instanceof JedisCluster) { return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, args);
}
if (nativeConnection instanceof Jedis) { return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, args);
}
return 0L;
});
return result != null result 0;
} catch (Throwable e) { logger.error( unlock occurred an exception , e);
}
return false;
}
}測試代碼
最后再來看看如何使用吧. (下面是一個模擬秒殺的場景)
@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisLockImplTest { private Logger logger = LoggerFactory.getLogger(getClass());
@Autowired
private RedisLock redisLock;
@Autowired
private StringRedisTemplate redisTemplate;
private ExecutorService executors = Executors.newScheduledThreadPool(8);
@Test
public void lock() {
// 初始化庫存
redisTemplate.opsForValue().set( goods-seckill , 10
List Future futureList = new ArrayList ();
for (int i = 0; i 100; i++) { futureList.add(executors.submit(this::seckill));
try { Thread.sleep(100);
} catch (InterruptedException e) { e.printStackTrace();
}
}
// 等待結果，防止主線程退出
futureList.forEach(action - {
try { action.get();
} catch (InterruptedException | ExecutionException e) { e.printStackTrace();
}
});
}
public int seckill() {
String key = goods
try { redisLock.lock(key);
int num = Integer.valueOf(Objects.requireNonNull(redisTemplate.opsForValue().get(goods-seckill)));
if (num 0) { redisTemplate.opsForValue().set(goods-seckill , String.valueOf(--num));
logger.info(秒殺成功，剩余庫存：{} , num);
} else { logger.error( 秒殺失敗，剩余庫存：{} , num);
}
return num;
} catch (Throwable e) { logger.error( seckill exception , e);
} finally { redisLock.unlock(key);
}
return 0;
}
}總結
本文是 Redis 鎖的一種簡單的實現方式，基于 jedis 實現了鎖的重試操作。
但是缺點還是有的，不支持鎖的自動續期，鎖的重入，以及公平性（目前通過自旋的方式實現，相當于是非公平的方式）。
“怎么理解 Redis 中的分布式鎖”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注丸趣 TV 網站，丸趣 TV 小編將為大家輸出更多高質量的實用文章！
正文完
