基于redis的分布式锁，可实现高并发

SETNX 命令：

        格式: setnx key value
        将key 的值设为value ，当且仅当key不存在。
        若给定的key已经存在，则SETNX不做任何动作。
        SETNX是「SET if Not eXists」(如果不存在，则SET)的简写。

不建议使用setnx；有缺陷

比如锁过期了线程还在处理任务，下一个线程开始获取锁并处理，然后上个线程开始释放锁，有可能上一个线程处理完释放的是下一个线程的锁。（可以通过一个唯一标识(uuid)去加锁，释放锁的时候根据唯一标识判断是否是自己的锁，）

例如：宕机后锁不能释放。

可以使用 redisson ，有看门狗机制，fork一个子线程去定时（10秒）的判断是否锁超时，如果还持有锁就延长生存的时间（加锁通过uuid+线程id作为锁的key），由于redis是AP高可用的机制，可以采用 Red Lock 的锁，只有主从节点同步完之后才会返回加锁成功。如果不采用Red Lock，是主节点加锁后就直接返回，如果主节点挂了，从节点是没有的

maven依赖

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.6.5</version>
        </dependency>

在springboot启动类添加redis配置 redisson

package com.benan.security.check.server;

import com.dtflys.forest.springboot.annotation.ForestScan;
import org.mybatis.spring.annotation.MapperScan;
import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;

@EnableDiscoveryClient
@SpringBootApplication(scanBasePackages = {"cn.isite90.common.component.schedule", "com.benan.security.check.server"})
@ForestScan(basePackages = {"cn.isite90","com.ruoyi"})
@MapperScan(basePackages = {"cn.isite90.common.component.schedule.mapper", "com.benan.security.check.server.mapper"})
public class BenanSecurityCheckApplication {

    public static void main(String[] args) {
        SpringApplication.run(BenanSecurityCheckApplication.class, args);
    }


    @Bean
    public Redisson redissonf(){
        //此为单机模式
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379").setDatabase(0);
       return(Redisson)Redisson.create(config);
    }


}

通过Autowired 注入到自己的类中  RLock  就是 RedLock

package com.benan.security.check.server.util;

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
 

public class TestAA {
 

    @Autowired
    private Redisson redisson;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    //秒杀场景
    public   void test( ) {
        String lockKey ="product_101";
        RLock redissonLock = redisson.getLock(lockKey);
            try {
                // 添加锁
                redissonLock.lock(); // 会保证原子性
                // 获取库存
                int stock = Integer.parseInt(redisTemplate.opsForValue().get("stock").toString());   // stock 库存    redisTemplate.opsForValue().get("stock") 就等于 jedis.get("stock") 
               // 判断是否有库存   防止超卖
                if(stock > 0){
                    // 扣减库存
                    int realStock = stock - 1;
                    //将当  剩余前库存添加到redis中
                    redisTemplate.opsForValue().set( "stock'", realStock + "");   //  jedis.set(key , value)
                    System.out.println("扣减成功，剩余库存" + realStock);
                }else {
                    System.out.println("扣减失败，库存不足");
                }
            }finally {
                //释放锁
                redissonLock.unlock();
            }
        }
}

redisson.lock 原理：

        主线程执行业务逻辑，然后会开辟一个子线程，子线程实时查看主线程是否执行完业务逻辑，如果没执行完，子线程会自动的添加锁的超时时间，防止超时后锁失效，