Redis分布式锁-库存案例
这里以扣库存为例子 先看代码
.
1.config配置包
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/*
* Redisson的配置类，提供RedissonClient实例
* */
@Configuration
public class RedissionConfiguration {
@Bean
public RedissonClient getRedissionClient(){
Config config=new Config();
//集群模式,集群节点的地址须使用“redis://”前缀，否则将会报错。
//此例集群为3节点，各节点1主1从
//config.useClusterServers().addNodeAddress("redis://192.168.37.134:7001","redis://192.168.37.134:7005","redis://192.168.37.134:7006");
//单例
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
return Redisson.create(config);
}
}
.
2.server
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
import java.util.concurrent.TimeUnit;
@Slf4j
@Repository
public class RedisServer {
@Autowired
private RedisTemplate<String,String> redisTemplate;
@Qualifier("getRedissionClient")//指定从本地自写的class中取得实例
@Autowired
private RedissonClient redissonClient;
/**
* 锁
* @param goodID 商品ID
* @param lockName 锁名
* @return
*/
public String redisLock(String goodID,String lockName){
RLock rLock = redissonClient.getLock(lockName);
//锁有效时间
rLock.lock(5, TimeUnit.SECONDS);
//业务代码 查询库存
int goodTotal = Integer.parseInt(redisTemplate.opsForValue().get(goodID));
if (goodTotal>0){
redisTemplate.opsForValue().set(goodID,String.valueOf(--goodTotal));
System.out.println(" lock 卖出一份，剩余库存："+goodTotal);
}else{
System.out.println(" 售空 ");
}
//业务完成 释放锁
rLock.unlock();
return String.valueOf(goodTotal);
}
/**
* 异常锁
* @param lockName 锁名
* @param goodId 商品ID
* @return
* @throws InterruptedException
*/
public String redisTryLockTest (String goodId,String lockName) throws InterruptedException {
boolean trylock = redisTryLock(lockName, 5L, 200L);
if (trylock){
//得到商品数量
int total = Integer.parseInt(redisTemplate.opsForValue().get(goodId));
if (total>0){
--total;
redisTemplate.opsForValue().set(goodId,String.valueOf(total));
}
Thread.sleep(50);
//解锁
redissonClient.getLock(lockName).unlock();
System.out.println(" tryLock 卖出一份，剩余库存："+redisTemplate.opsForValue().get(goodId));
}else {
System.out.println(" 获取锁失败："+lockName);
}
return "执行完";
}
/**
* 加锁操作(tryLock锁，有等待时间）
* @param lockName 锁名称
* @param leaseTime 锁有效时间
* @param waitTime 等待时间
* @return
*/
public boolean redisTryLock(String lockName,long leaseTime,long waitTime){
RLock rLock = redissonClient.getLock(lockName);
boolean getLock=false;
try {
//加锁
getLock = rLock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
} catch (InterruptedException e) {
log.error("获取Redisson分布式锁[异常]，lockName=" + lockName, e);
e.printStackTrace();
return false;
}
return getLock;
}
/**
* 解锁
* @param lockName 锁名称
*/
public void unlock(String lockName) {
redissonClient.getLock(lockName).unlock();
}
}
.
3.controller
import com.knife.redis.RedisServer;
import org.redisson.Redisson;
import org.redisson.RedissonRedLock;
import org.redisson.api.RLock;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.redisson.config.Config;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
*
* 前端控制器
*
* @author 胡图图
* @since 2021-03-12
*/
@RestController
public class RedisController {
@Autowired
private RedisTemplate<String,String> redisTemplate;
@Autowired
private RedisServer redisServer;
//锁
@RequestMapping("redisLockTest")
public String redisTest (){
for (int i=0;i<101;i++){
redisServer.redisLock("goodShop","goodLock");
}
return "执行完";
}
//try锁
@RequestMapping("redisTryLockTest")
public String redisTryLockTest () throws InterruptedException {
String trylockName = "trylock";
String goodId = "goodShop";
for (int i=0;i<101;i++){
boolean trylock = redisServer.redisTryLock(trylockName, 5L, 200L);
if (trylock){
//得到商品数量
int total = Integer.parseInt(redisTemplate.opsForValue().get(goodId));
if (total>0){
--total;
redisTemplate.opsForValue().set(goodId,String.valueOf(total));
}
Thread.sleep(50);
//解锁
redisServer.unlock(trylockName);
System.out.println("卖出一份，剩余库存："+redisTemplate.opsForValue().get(goodId));
}else {
System.out.println(" 获取锁失败："+trylockName);
}
}
return "执行完";
}
//调用俩方法测试 redisLock redisTryLockTest
@RequestMapping("redisLock")
public String redisLockTryLock(){
String lockName ="goodLock";
String goodShop = "goodShop";
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
for (int i = 0; i < 101; i++) {
fixedThreadPool.execute(new Runnable() {
@Override
public void run() {
redisServer.redisLock(goodShop,lockName);
try {
redisServer.redisTryLockTest(goodShop,lockName);
} catch (InterruptedException e) {
System.out.println(" 获取锁失败："+lockName);
e.printStackTrace();
}
}
});
}
return "执行完成";
}
}
.
为什么要用分布式锁
1.服务A去Redis查询到库存发现是1，那说明我能抢到这个商品对不对，那我就准备减一了，但是还没减。
2.同时服务B也去拿发现也是1，那我也抢到了呀，那我也减。
3.C同B，也去减。
4.等所有的服务都判断完了，你发现诶，怎么变成-2了，超卖了呀，这下完了。
所以需要用锁来控制库存。
.
代码运行讲解
.
1.redisLock方法
.
2.redisTryLock方法
.
3.调用以上两种方法，模拟两用户购买商品
.
.
.
以上是我自己学习自己写的代码，看了很多博主的文章依然很懵看不明白一点都不通俗，在本地跑还保错，希望我写的能够帮助大家。
.
.
.