Redis+IDEA实现单机锁和分布式锁的过程
更新时间：2023年07月14日 09:54:30 作者：kkoneone11
这篇文章主要介绍了Redis+IDEA实现单机锁和分布式锁的过程,本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
单机下：
只适用于单机环境下（单个JVM），多个客户端访问同一个服务器
1.synchronized
package com.cloud.SR.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
public class TestConrtoller1 {
@Value("${server.port}")
private String serverPort;
@Resource
private StringRedisTemplate stringRedisTemplate;
@GetMapping("/buy1")
public String shopping(){
synchronized (this){
String result = stringRedisTemplate.opsForValue().get("goods:001");
int total = result == null? 0 :Integer.parseInt(s);
if(total > 0){
int realTotal = total - 1;
stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
return "剩余商品为："+realTotal +",提供服务的端口号："+serverPort;
}else{
System.out.println("购买商品失败！");
}
return "购买商品失败！";
}
}
}
2.ReentrantLock
@RestController
public class TestConrtoller2 {
@Value("${server.port}")
private String serverPort;
// 使用ReentrantLock锁解决单体应用的并发问题
Lock lock = new ReentrantLock();
@Autowired
StringRedisTemplate stringRedisTemplate;
@RequestMapping("/buy2")
public String index() {
lock.lock();
try {
String result = stringRedisTemplate.opsForValue().get("goods:001");
int total = result == null ? 0 : Integer.parseInt(result);
if (total > 0) {
int realTotal = total - 1;
stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩：" + realTotal + "，服务端口为:"+serverPort);
return "购买商品成功，库存还剩：" + realTotal + "，服务端口为："+serverPort;
} else {
System.out.println("购买商品失败！");
}
} catch (Exception e) {
lock.unlock();
} finally {
lock.unlock();
}
return "购买商品失败！";
}
}分布式下：
而在服务器分布式集群下，，单个服务器的synchronized和ReentrantLock
1.SETNX
SET key value [EX seconds] [PX milliseconds] [NX|XX]
EXseconds – 设置键key的过期时间，单位时秒PXmilliseconds – 设置键key的过期时间，单位时毫秒NX– 只有键key不存在的时候才会设置key的值XX– 只有键key存在的时候才会设置key的值
例子：
1.set lock01 01 NX ：意思就是说只要谁把key为lock01的值设置为01且key不存在的时候就能拿到锁
2. set lock01 01 NX EX 30 ：在例1的基础上把锁设置的时间设置为30秒后过期。避免有服务挂了而没有释放锁的情况、或者业务处理完但一直拿着锁不释放导致死锁。
项目中使用SETNX：
template.opsForValue().setIfAbsent()
测试的话就得本机模拟集群，当然有虚拟机的也可以用两台虚拟机，但此处用两台JVM即可完成简易集群本机实现集群的可以看这篇文章：http://t.csdn.cn/jvZFx
先让集群跑起来，然后启动Nginx，再通过Jmeter实现高并发的秒杀环节
用template.opsForValue().setIfAbsent()命令进行加锁。加上了过期时间后就解决了key无法删除的问题，但如果key设置的时间太短，当业务处理的时间长于key设置的时间，key过期后其他请求就可以设置这个key而当这个线程再回来处理这个程序的时候就会把人家设置的key给删除了，因此我们规定谁设置的锁只能由谁删除。
finally {
// 谁加的锁，谁才能删除
if(template.opsForValue().get(REDIS_LOCK).equals(value)){
template.delete(REDIS_LOCK);
}而新的问题就是finally块的判断和del删除操作不是原子操作，并发的时候也会出问题。因此采用lua（原子性）来进行删除
finally {
// 谁加的锁，谁才能删除，使用Lua脚本，进行锁的删除
Jedis jedis = null;
try{
jedis = RedisUtils.getJedis();
String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
"then " +
"return redis.call('del',KEYS[1]) " +
"else " +
" return 0 " +
"end";
Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
if("1".equals(eval.toString())){
System.out.println("-----del redis lock ok....");
}else{
System.out.println("-----del redis lock error ....");
}
}catch (Exception e){
}finally {
if(null != jedis){
jedis.close();
}
}总的代码：
@RestController
public class TestConrtoller3 {
@Value("${server.port}")
private String serverPort;
public static final String REDIS_LOCK = "good_lock";
@Autowired
StringRedisTemplate stringtemplate;
@RequestMapping("/buy3")
public String shopping(){
// 每个人进来先要进行加锁，key值为"good_lock",且用UUID保证每个人的锁不同
String value = UUID.randomUUID().toString().replace("-","");
try{
// 为key加一个过期时间
Boolean flag = stringtemplate.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
// 加锁失败
if(!flag){
return "抢锁失败！";
}
System.out.println( value+ " 抢锁成功");
String result = stringtemplate.opsForValue().get("goods:001");
int total = result == null ? 0 : Integer.parseInt(result);
if (total > 0) {
// 如果在此处需要调用其他微服务，处理时间较长。。。
int realTotal = total - 1;
stringtemplate.opsForValue().set("goods:001", String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩：" + realTotal + "，服务端口为"+serverPort);
return "购买商品成功，库存还剩：" + realTotal + "服务端口为"+serverPort;
} else {
System.out.println("购买商品失败");
}
return "购买商品失败！";
}finally {
// 谁加的锁，谁才能删除，使用Lua脚本，进行锁的删除
Jedis jedis = null;
try{
jedis = RedisUtils.getJedis();
String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
"then " +
"return redis.call('del',KEYS[1]) " +
"else " +
" return 0 " +
"end";
Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
if("1".equals(eval.toString())){
System.out.println("-----del redis lock ok....");
}else{
System.out.println("-----del redis lock error ....");
}
}catch (Exception e){
}finally {
if(null != jedis){
jedis.close();
}
}
}
}
}2.Redisson(推荐)
考虑缓存续命，以及Redis集群部署下，异步复制造成的锁丢失：主节点没来得及把刚刚set进来这条数据给从节点，就挂了。所以直接上RedLock的Redisson落地实现
@RestController
public class TestConrtoller4 {
@Value("${server.port}")
private String serverPort;
public static final String REDIS_LOCK = "good_lock";
@Autowired
StringRedisTemplate stringtemplate;
@Autowired
Redisson redisson;
@RequestMapping("/buy4")
public String shopping(){
RLock lock = redisson.getLock(REDIS_LOCK);
lock.lock();
// 每个人进来先要进行加锁，key值为"good_lock"
String value = UUID.randomUUID().toString().replace("-","");
try{
String result = stringtemplate.opsForValue().get("goods:001");
int total = result == null ? 0 : Integer.parseInt(result);
if (total > 0) {
// 如果在此处需要调用其他微服务，处理时间较长
int realTotal = total - 1;
stringtemplate.opsForValue().set("goods:001", String.valueOf(realTotal));
System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为"+serverPort);
return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为"+serverPort;
} else {
System.out.println("购买商品失败");
}
return "购买商品失败";
}finally {
if(lock.isLocked() && lock.isHeldByCurrentThread()){
lock.unlock();
}
}
}
}Redis工具类
import com.myfutech.common.util.constant.RedisPrefix;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import java.nio.charset.StandardCharsets;
import java.util.UUID;
/**
* 基于redis分布式锁
*/
@Slf4j
public class RedisLockUtils {
/**
* 默认轮休获取锁间隔时间， 单位：毫秒
*/
private static final int DEFAULT_ACQUIRE_RESOLUTION_MILLIS = 100;
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();
}
/**
* 获取锁，没有获取到则一直等待，异常情况则返回null
*
* @param redisTemplate redis连接
* @param key redis key
* @param expire 锁过期时间, 单位 秒
* @return 当前锁唯一id，如果没有获取到，返回 null
*/
public static String lock(RedisTemplate redisTemplate, final String key, long expire){
return lock(redisTemplate, key, expire, -1);
}
/**
* 获取锁，acquireTimeout时间内没有获取到，则返回null，异常情况返回null
*
* @param redisTemplate redis连接
* @param key redis key
* @param expire 锁过期时间, 单位 秒
* @param acquireTimeout 获取锁超时时间, -1代表永不超时, 单位 秒
* @return 当前锁唯一id，如果没有获取到，返回 null
*/
public static String lock(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
try {
return acquireLock(redisTemplate, key, expire, acquireTimeout);
} catch (Exception e) {
log.error("acquire lock exception", e);
}
return null;
}
/**
* 获取锁，没有获取到则一直等待，没有获取到则抛出异常
*
* @param redisTemplate redis连接
* @param key redis key
* @param expire 锁过期时间, 单位 秒
* @return 当前锁唯一id，如果没有获取到，返回 null
*/
public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire){
return lockFailThrowException(redisTemplate, key, expire, -1);
}
/**
* 获取锁，到达超时时间时没有获取到，则抛出异常
*
* @param redisTemplate redis连接
* @param key redis key
* @param expire 锁过期时间, 单位 秒
* @param acquireTimeout 获取锁超时时间, -1代表永不超时, 单位 秒
* @return 当前锁唯一id，如果没有获取到，返回 null
*/
public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
try {
String lockId = acquireLock(redisTemplate, key, expire, acquireTimeout);
if (lockId != null) {
return lockId;
}
throw new RuntimeException("acquire lock fail");
} catch (Exception e) {
throw new RuntimeException("acquire lock exception", e);
}
}
private static String acquireLock(RedisTemplate redisTemplate, String key, long expire, long acquireTimeout) throws InterruptedException {
long acquireTime = -1;
if (acquireTimeout != -1) {
acquireTime = acquireTimeout * 1000 + System.currentTimeMillis();
}
synchronized (key) {
String lockId = UUID.randomUUID().toString();
while (true) {
if (acquireTime != -1 && acquireTime < System.currentTimeMillis()) {
break;
}
//调用tryLock
boolean hasLock = tryLock(redisTemplate, key, expire, lockId);
//获取锁成功
if (hasLock) {
return lockId;
}
Thread.sleep(DEFAULT_ACQUIRE_RESOLUTION_MILLIS);
}
}
return null;
}
/**
* 释放锁
*
* @param redisTemplate redis连接
* @param key redis key
* @param lockId 当前锁唯一id
*/
public static void unlock(RedisTemplate redisTemplate, String key, String lockId) {
try {
RedisCallback<Boolean> callback = (connection) ->
connection.eval(UNLOCK_LUA.getBytes(StandardCharsets.UTF_8),ReturnType.BOOLEAN, 1,
(RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8), lockId.getBytes(StandardCharsets.UTF_8));
redisTemplate.execute(callback);
} catch (Exception e) {
log.error("release lock exception", e);
}
}
/**
* 获取当前锁的id
*
* @param key redis key
* @return 当前锁唯一id
*/
public static String get(RedisTemplate redisTemplate, String key) {
try {
RedisCallback<String> callback = (connection) -> {
byte[] bytes = connection.get((RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8));
if (bytes != null){
return new String(bytes, StandardCharsets.UTF_8);
}
return null;
};
return (String)redisTemplate.execute(callback);
} catch (Exception e) {
log.error("get lock id exception", e);
}
return null;
}
private static boolean tryLock(RedisTemplate redisTemplate, String key, long expire, String lockId) {
RedisCallback<Boolean> callback = (connection) ->
connection.set((RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8),
lockId.getBytes(StandardCharsets.UTF_8), Expiration.seconds(expire), RedisStringCommands.SetOption.SET_IF_ABSENT);
return (Boolean)redisTemplate.execute(callback);
}
}到此这篇关于Redis+IDEA极速了解和实现单机锁和分布式锁的文章就介绍到这了,更多相关Redis单机锁和分布式锁内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
本文主要介绍了Redis的缓存类型，主要介绍了4种缓存，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2023-06-06
Redis Streams是Redis 5.0新增的数据类型,提供了一种日志结构化数据存储方式,这种类型适合用于构建消息队列、事件日志和处理时间序列数据的应用,本文介绍Redis 数据类型Streams相关知识,感兴趣的朋友一起看看吧2024-10-10
这篇文章主要介绍了推荐几款 Redis 可视化工具,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2021-04-04
RedisTemplate 实现基于Value 操作的简易锁机制(示例代码)
本文将介绍如何使用 RedisTemplate 的 opsForValue().setIfAbsent() 方法来实现一种简单的锁机制,并提供一个示例代码,展示如何在 Java 应用中利用这一机制来保护共享资源的访问,感兴趣的朋友跟随小编一起看看吧2024-05-05
Jackson2JsonRedisSerializer和GenericJackson2JsonRedisSerializ
本文主要介绍了Jackson2JsonRedisSerializer和GenericJackson2JsonRedisSerializer区别，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2023-04-04
这篇文章主要介绍了Redis解决优惠券秒杀应用案例,本文先讲了抢购问题，指出其中会出现的多线程问题，提出解决方案采用悲观锁和乐观锁两种方式进行实现，然后发现在抢购过程中容易出现一人多单现象，需要的朋友可以参考下2022-12-12
本文主要介绍了浅谈Redis中的自动过期机制，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2022-05-05
CentOS7.5使用mysql_multi方式安装MySQL5.7.28多实例(详解)
这篇文章主要介绍了CentOS7.5使用mysql_multi方式安装MySQL5.7.28多实例,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下2020-01-01
在 React 中,组件之间的通信是构建复杂应用程序的核心部分,良好的组件间通信能够提高代码的可维护性和可读性,同时能够高效地管理应用状态,在这篇博客中,我们将探讨 React中几种常用的组件通信方法,并提供示例代码来帮助你理解,需要的朋友可以参考下2025-02-02
这篇文章主要介绍了Redis bitmap 实现签到案例,通过设计签到功能对应的数据库表,结合sql语句给大家讲解的非常详细,具体示例代码跟随小编一起看看吧2024-07-07
最新评论