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.调用以上两种方法，模拟两用户购买商品

.
.
.
以上是我自己学习自己写的代码，看了很多博主的文章依然很懵看不明白一点都不通俗，在本地跑还保错，希望我写的能够帮助大家。
.
.
.