wget https://download.redis.io/releases/redis-6.2.1.tar.gz 

tar -xzvf redis-6.2.1.tar.gz 

yum install gcc

# 测试
gcc --version

make		# 若报无.h文件则执行 make distclean
make install

# 前台启动
redis-server

# 原来
daemonize no
# 修改后
daemonize yes

redis-server /etc/redis.conf

select [index]

# Note on units: when memory size is needed, it is possible to specify
# it in the usual form of 1k 5GB 4M and so forth:
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.

################################## INCLUDES ###################################

# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all Redis servers but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# Note that option "include" won't be rewritten by command "CONFIG REWRITE"
# from admin or Redis Sentinel. Since Redis always uses the last processed
# line as value of a configuration directive, you'd better put includes
# at the beginning of this file to avoid overwriting config change at runtime.
#
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
#
# include /path/to/local.conf
# include /path/to/other.conf

bind 127.0.0.1 -::1

protected-mode yes

port 6379

tcp-backlog 511

timeout 0

tcp-keepalive 300

daemonize yes

pidfile /var/run/redis_6379.pid

loglevel notice

logfile ""

databases 16

# requirepass foobared

config get requirepass # 查看密码
config set requirepass "123456"	# 设置密码
auth 123456 # 登录

# maxclients 10000

# maxmemory <bytes>

# maxmemory-policy noeviction

# maxmemory-samples 5

# You can set these explicitly by uncommenting the three following lines.
#
# save 3600 1
# save 300 100
# save 60 10000

# However if you have setup your proper monitoring of the Redis server
# and persistence, you may want to disable this feature so that Redis will
# continue to work as usual even if there are problems with disk,
# permissions, and so forth.
stop-writes-on-bgsave-error yes

# Compress string objects using LZF when dump .rdb databases?
# By default compression is enabled as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes

# RDB files created with checksum disabled have a checksum of zero that will
# tell the loading code to skip the check.
rdbchecksum yes

SUBSCRIBE channel1

publish channel1 hello

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>

public class JedisDemo1 {
    private static final Jedis jedis =
            new Jedis("IP地址", 端口号);

    static {
        jedis.auth("密码");
    }

    @Test
    public void demo1(){
        jedis.set("k1", "v1");                      // 设置键值对
        System.out.println(jedis.get("k1"));        // 获取键对应的值
        System.out.println(jedis.ttl("k1"));    // 查看过期时间
        System.out.println(jedis.exists("k1"));   // 查看键对应的值是否存在
        jedis.expire("k1", 300);        // 设置超时时间
        jedis.mset("k2", "v2", "k3", "v3"); // 批量设置键值对
        System.out.println(jedis.mget("k1", "k2", "k3"));   // 批量获取值
    }

    @Test
    public void demo2(){
        jedis.lpush("key1", "lucy", "mary", "jack");    // list添加
        List<String> key1 = jedis.lrange("key1", 0, -1);    // 获取list
        System.out.println(key1);
    }

    @Test
    public void demo3(){
        jedis.sadd("name1", "value1", "value2", "value3");  // set添加
        Set<String> name1 = jedis.smembers("name1");    // 获取set
        System.out.println(name1);
    }

    @Test
    public void demo4(){
        jedis.hset("user", "age", "20");
        jedis.hset("user", "name", "zhangsan");
        Map<String, String> user = jedis.hgetAll("user");
        System.out.println(user);
    }

    @Test
    public void demo5(){
        jedis.zadd("key3", 100, "zhangsan");
        jedis.zadd("key3", 200, "lisi");
        List<String> key3 = jedis.zrange("key3", 0, -1);
        System.out.println(key3);
    }
}

public class RedisUtil {
    private static final Jedis jedis =
            new Jedis("ip", 端口号);

    static {
        jedis.auth("密码");
    }

    public static Boolean confirm(String tel, String confirm){
        String codeKey = "VerifyCode" + tel + ":code";
        String s = jedis.get(codeKey);
        if (s != null && s.equals(confirm)) {

            return true;
        }
        return false;
    }

    public static int stockConfirm(String tel, String confirm){
        String countKey = "VerifyCode" + tel + ":count";
        String codeKey = "VerifyCode" + tel + ":code";
        String count = jedis.get(codeKey);
        if (count == null) {
            jedis.setex(countKey, (int) DateUtil.getSecond(), "1");
        } else if (Integer.parseInt(count) <= 2) {
            jedis.incr(countKey);
        } else {
            return -1;
        }
        jedis.setex(codeKey, 120, confirm);
        return 1;
    }
}

public class RandomUtil {
    static Random random = new Random();

    public static String getCode(){
        StringBuilder code = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            code.append(random.nextInt(10));
        }
        System.out.println("生成的验证码：" + code);
        return code.toString();
    }
}

public class DateUtil {
    public static long getSecond(){
        LocalDateTime midnight = LocalDateTime.now().plusDays(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
        return ChronoUnit.SECONDS.between(LocalDateTime.now(),midnight);
    }
}

public class PhoneCode {
    public static void main(String[] args) {
        System.out.println("请输入手机号");
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        RedisUtil.stockConfirm(s, RandomUtil.getCode());
        System.out.println("请输入验证码");
        String s1 = scanner.nextLine();
        System.out.println("是否相等：" + RedisUtil.confirm(s, s1));

    }
}

<!--连接池-->
<dependency>    
    <groupId>com.alibaba</groupId>    
    <artifactId>druid-spring-boot-starter</artifactId>    
<version>1.2.8</version></dependency>

<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

#Redis服务器地址
spring.redis.host=ip地址
#Redis服务器连接端口
spring.redis.port=端口号
spring.redis.password=密码
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
		//key序列化方式
        template.setKeySerializer(redisSerializer);
		//value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
		//value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
		//解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
		// 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping
    public String testRedis() {
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }
}

WATCH key [key ...]

unwatch

yum install httpd-tools

ab -n 2000 -c 200 -k -p ~/postfile -T application/x-www-form-urlencoded http://ip地址:端口号/Seckill/doseckill

# The filename where to dump the DB
dbfilename dump.rdb

# Note that you must specify a directory here, not a file name.
dir ./

# Unless specified otherwise, by default Redis will save the DB:
#   * After 3600 seconds (an hour) if at least 1 key changed
#   * After 300 seconds (5 minutes) if at least 100 keys changed
#   * After 60 seconds if at least 10000 keys changed
#
# You can set these explicitly by uncommenting the three following lines.
#
# save 3600 1
# save 300 100
# save 60 10000

# AOF and RDB persistence can be enabled at the same time without problems.
# If the AOF is enabled on startup Redis will load the AOF, that is the file
# with the better durability guarantees.
#
# Please check http://redis.io/topics/persistence for more information.

appendonly no

# The name of the append only file (default: "appendonly.aof")

appendfilename "appendonly.aof"

# 始终同步，每次Redis的写入都会立刻记入日志；性能较差但数据完整性比较好
# appendfsync always

# 每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失。默认
appendfsync everysec

# redis不主动进行同步，把同步时机交给操作系统。
# appendfsync no

[root@VM-4-3-centos myredis]# ll
total 104
-rw-r--r-- 1 root root    94 Oct  8 21:56 redis7379.conf
-rw-r--r-- 1 root root    94 Oct  8 21:54 redis7380.conf
-rw-r--r-- 1 root root    94 Oct  8 21:55 redis7381.conf
-rw-r--r-- 1 root root 92251 Oct  8 21:48 redis.conf

include /myredis/redis.conf
pidfile /var/run/redis_7379.pid
port 7379
dbfilename dump7379.rdb

[root@VM-4-3-centos myredis]# redis-server redis7379.conf
[root@VM-4-3-centos myredis]# redis-server redis7380.conf
[root@VM-4-3-centos myredis]# redis-server redis7381.conf
[root@VM-4-3-centos myredis]# ps -ef | grep redis
root     11882     1  0 22:44 ?        00:00:00 redis-server *:7379
root     11904     1  0 22:44 ?        00:00:00 redis-server *:7380
root     11910     1  0 22:44 ?        00:00:00 redis-server *:7381
root     11938 11666  0 22:44 pts/2    00:00:00 grep --color=auto redis

127.0.0.1:7381> info replication
# Replication
role:master
connected_slaves:0
master_failover_state:no-failover
master_replid:c7bc6e8b3de76c02e840f1e8dbf44a45ad8de31a
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

127.0.0.1:7380> slaveof 127.0.0.1 7379
OK
127.0.0.1:7380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:7379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_repl_offset:1
master_link_down_since_seconds:1665240856
slave_priority:100
slave_read_only:1
connected_slaves:0
master_failover_state:no-failover
master_replid:fcfd9b42be2f292f9ce5d186eb534626b674e4cb
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

sentinel monitor mymaster 127.0.0.1 7379 1

redis-sentinel  /myredis/sentinel.conf 

include /myredis/redis.conf
pidfile /var/run/redis_7379.pid
port 7379
dbfilename dump7379.rdb

# 打开集群模式
cluster-enabled yes
# 设定节点配置文件名
cluster-config-file nodes-7379.conf
# 设定节点失联时间，超过该时间（毫秒），集群自动进行主从切换。
cluster-node-timeout 15000 

[root@VM-4-3-centos myredis]# ll
total 104
-rw-r--r-- 1 root root    94 Oct  8 21:56 redis7379.conf
-rw-r--r-- 1 root root    94 Oct  8 21:54 redis7380.conf
-rw-r--r-- 1 root root    94 Oct  8 21:55 redis7381.conf
-rw-r--r-- 1 root root    94 Oct  8 23:48 redis7389.conf
-rw-r--r-- 1 root root    94 Oct  8 23:49 redis7390.conf
-rw-r--r-- 1 root root    94 Oct  8 23:50 redis7391.conf
-rw-r--r-- 1 root root 92251 Oct  8 21:48 redis.conf

redis-cli --cluster create --cluster-replicas 1 ip地址:7379 ip地址:7380 ip地址:7381 ip地址:7389 ip地址:7390 ip地址:7391

[OK] All nodes agree about slots configuration 
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered

redis-cli -c -p 7379

[OK] All nodes agree about slots configuration 
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered

ip: 7379 > set k1 v1
-> Redirected to slot [12706] at ip:7381

ip:7379 > mset k1 v1 k2 v2 k3 v3
(error) CROSSLOT Keys in request don't hash to the same slot
ip:7379 > mset k1{cust} v1 k2{cust} v2 k3{cust} v3
-> Redirected to slot [4847] at ip:7379

public class JedisClusterTest {
    public static void main(String[] args) { 
        hostAndPort = new HostAndPort("ip",port);
        JedisCluster jedisCluster=new JedisCluster(hostAndPort);
        jedisCluster.set("k1", "v1");
        System.out.println(jedisCluster.get("k1"));
    }
}

public void testLockLua() {
    String uuid = UUID.randomUUID().toString();
    String skuId = "25"; // 25号商品的数据
    String locKey = "lock:" + skuId;

    Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);

    if (lock) {
        Object value = redisTemplate.opsForValue().get("num");
        if (StringUtils.isEmpty(value)) {
            return;
        }
        int num = Integer.parseInt(value + "");
        redisTemplate.opsForValue().set("num", String.valueOf(++num));
        
        // 定义lua 脚本
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        // 使用redis执行lua执行
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(script);
        redisScript.setResultType(Long.class);
        // 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
        redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
    } else {
        try {
            Thread.sleep(1000);
            testLockLua();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Slf4j
@SuppressWarnings({"all"})
public class RedisDistributedLock implements Lock {

    private final StringRedisTemplate redisTemplate;

    /**
     * 锁的名称，Map<String, <Map<String, Integer>> 中的第一个String
     */
    private final String lockName;

    /**
     * Map<String, <Map<String, Integer>> 中的第二个String
     */
    private final String value;

    private static final long EXPIRE_TIME = 5L;

    public RedisDistributedLock(StringRedisTemplate redisTemplate, String lockName, String uuid) {
        this.redisTemplate = redisTemplate;
        this.lockName = lockName;
        // uuid从工厂传进来, 保证唯一性
        this.value = uuid + "-" + Thread.currentThread().getId();
    }

    @Override
    public void lock() {
        tryLock();
    }

    @Override
    public void unlock() {
        // 解锁的Lua脚本
        String script = LuaScript.LUA_UNLOCK_SCRIPT;
        Long result = redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), List.of(lockName), value);
        if (null == result) {
            throw new RuntimeException("The Lock doesn't exists.");
        }
        log.info("unlock {} success. ", lockName);
    }

    @Override
    public boolean tryLock() {
        return tryLock(-1L, TimeUnit.SECONDS);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) {
        if (-1L == time) {
            // 加锁的Lua脚本
            String script = LuaScript.LUA_LOCK_SCRIPT;
            while(!redisTemplate.execute(new DefaultRedisScript<>(script,Boolean.class), Arrays.asList(lockName), value,String.valueOf(EXPIRE_TIME))) {
                ThreadUtils.sleep(EXPIRE_TIME);
            }
            log.info("lock {} success. ", lockName);
            return true;
        }
        return false;
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // unused
    }

    @Override
    public Condition newCondition() {
        // unused
        return null;
    }
}

public class LuaScript {

    private LuaScript() {}

    public static final String LUA_LOCK_SCRIPT =
            "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then    " +
                "redis.call('hincrby',KEYS[1],ARGV[1],1)    " +
                "redis.call('expire',KEYS[1],ARGV[2])    " +
                "return 1  " +
            "else   " +
                "return 0 " +
            "end";

    public static final String LUA_UNLOCK_SCRIPT =
            "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 0 then    " +
                "return nil  " +
            "elseif redis.call('HINCRBY',KEYS[1],ARGV[1],-1) == 0 then    " +
                "return redis.call('del',KEYS[1])  " +
            "else    " +
                "return 0 " +
            "end";
}

@Component
@SuppressWarnings("unused")
public class DistributedLockFactory {

    private final String uuid;

    private final StringRedisTemplate redisTemplate;

    public DistributedLockFactory(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.uuid = IdUtil.simpleUUID();
    }

    public Lock getDistributedLock(LockEnum type) {
        return switch (type) {
            // Java17新特性
            case REDIS -> new RedisDistributedLock(redisTemplate, LockNameConstants.REDIS_LOCK_NAME, uuid);
            // TODO 补充
            case ZOOKEEPER, MYSQL -> null;
        };
    }

}

public String sale() {
    String retMessage;

    Lock redisLock = distributedLockFactory.getDistributedLock(LockEnum.REDIS);
    redisLock.lock();
    try {
        //1 查询库存信息
        String result = redisTemplate.opsForValue().get("inventory001");
        //2 判断库存是否足够
        int inventoryNumber = result == null ? 0 : Integer.parseInt(result);
        //3 扣减库存，每次减少一个
        if (inventoryNumber > 0) {
            redisTemplate.opsForValue().set("inventory001", String.valueOf(--inventoryNumber));
            retMessage = "成功卖出一个商品,库存剩余: " + inventoryNumber;
            ThreadUtils.sleep(20);
            testReEntry();
        } else {
            retMessage = "商品卖完了";
        }
        log.info("{} \t 服务端口号: {}", retMessage, port);
    } finally {
        redisLock.unlock();
    }
    return retMessage + "\t" + "服务端口号" + port;
}

private void testReEntry() {
    Lock redisLock = distributedLockFactory.getDistributedLock(LockEnum.REDIS);
    redisLock.lock();
    try
    {
        log.info("测试可重入锁");
    }finally {
        redisLock.unlock();
    }
}

[root@localhost ~]# redis-cli -a Redis密码 --bigkeys
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

# Scanning the entire keyspace to find biggest keys as well as
# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
# per 100 SCAN commands (not usually needed).

[00.00%] Biggest string found so far '"k5889"' with 5 bytes
[00.00%] Biggest string found so far '"k607267"' with 7 bytes
[00.00%] Biggest string found so far '"k1802564"' with 8 bytes
[50.00%] Sampled 1000000 keys so far
[100.00%] Sampled 2000000 keys so far

-------- summary -------

Sampled 2000000 keys in the keyspace!
Total key length in bytes is 14888896 (avg len 7.44)

Biggest string found '"k1802564"' has 8 bytes

0 lists with 0 items (00.00% of keys, avg size 0.00)
0 hashs with 0 fields (00.00% of keys, avg size 0.00)
2000000 strings with 14888896 bytes (100.00% of keys, avg size 7.44)
0 streams with 0 entries (00.00% of keys, avg size 0.00)
0 sets with 0 members (00.00% of keys, avg size 0.00)
0 zsets with 0 members (00.00% of keys, avg size 0.00)

127.0.0.1:6379> MEMORY USAGE k10000
(integer) 64

public void delBigHash(String bigHashKey) {
    ScanParams scanParams = new ScanParams().count(100);
    String cursor = "0";
    do {
        ScanResult<Entry<String, String>> scanResult = jedis.hscan(bigHashKey, cursor, scanParams);
        List<Entry<String, String>> entryList = scanResult.getResult();
        if (CollectionUtils.isNotEmpty(entryList)) {
            for (Entry<String, String> entry : entryList) {
                jedis.hdel(bigHashKey, entry.getKey());
            }
        }
        cursor = scanResult.getCursor();
    } while (!"0".equals(cursor));
    jedis.del(bigHashKey);
}

public void delBigList(String bigListKey){
    long llen = jedis.llen(bigListKey);
    int counter = 0;
    int left = 100;
    while (counter < llen) {
        jedis.ltrim(bigListKey, left, llen);
        counter += left;
    }
    jedis.del(bigListKey);
}

public void delBigSet(String bigSetKey){
    ScanParams scanParams = new ScanParams().count(100);
    String cursor = "0";
    do {
        ScanResult<String> scanResult = jedis.sscan(bigSetKey, cursor, scanParams);
        List<String> memberList = scanResult.getResult();
        if (CollectionUtils.isNotEmpty(memberList)) {
            for (String member : memberList) {
                jedis.srem(bigSetKey, member);
            }
        }
        cursor = scanResult.getCursor();
    } while (!"0".equals(cursor));
    jedis.del(bigSetKey);
}

public void delBigZSet(String bigZSetKey){
    ScanParams scanParams = new ScanParams().count(100);
    String cursor = "0";
    do {
        ScanResult<Tuple> scanResult = jedis.zscan(bigZSetKey, cursor, scanParams);
        List<Tuple> tupleList = scanResult.getResult();
        if (CollectionUtils.isNotEmpty(tupleList)) {
            for (Tuple tuple : tupleList) {
                jedis.zrem(bigZSetKey, tuple.getElement());
            }
        }
        cursor = scanResult.getCursor();
    } while (!"0".equals(cursor));
    jedis.del(bigZSetKey);
}

public void testLockLua() {
    String uuid = UUID.randomUUID().toString();
    String skuId = "25"; // 25号商品的数据
    String locKey = "lock:" + skuId;

    Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);

    if (lock) {
        Object value = redisTemplate.opsForValue().get("num");
        if (StringUtils.isEmpty(value)) {
            return;
        }
        int num = Integer.parseInt(value + "");
        redisTemplate.opsForValue().set("num", String.valueOf(++num));
        
        // 定义lua 脚本
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        // 使用redis执行lua执行
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(script);
        redisScript.setResultType(Long.class);
        // 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
        redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
    } else {
        try {
            Thread.sleep(1000);
            testLockLua();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Slf4j
@SuppressWarnings({"all"})
public class RedisDistributedLock implements Lock {

    private final StringRedisTemplate redisTemplate;

    /**
     * 锁的名称，Map<String, <Map<String, Integer>> 中的第一个String
     */
    private final String lockName;

    /**
     * Map<String, <Map<String, Integer>> 中的第二个String
     */
    private final String value;

    private static final long EXPIRE_TIME = 5L;

    public RedisDistributedLock(StringRedisTemplate redisTemplate, String lockName, String uuid) {
        this.redisTemplate = redisTemplate;
        this.lockName = lockName;
        // uuid从工厂传进来, 保证唯一性
        this.value = uuid + "-" + Thread.currentThread().getId();
    }

    @Override
    public void lock() {
        tryLock();
    }

    @Override
    public void unlock() {
        // 解锁的Lua脚本
        String script = LuaScript.LUA_UNLOCK_SCRIPT;
        Long result = redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), List.of(lockName), value);
        if (null == result) {
            throw new RuntimeException("The Lock doesn't exists.");
        }
        log.info("unlock {} success. ", lockName);
    }

    @Override
    public boolean tryLock() {
        return tryLock(-1L, TimeUnit.SECONDS);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) {
        if (-1L == time) {
            // 加锁的Lua脚本
            String script = LuaScript.LUA_LOCK_SCRIPT;
            while(!redisTemplate.execute(new DefaultRedisScript<>(script,Boolean.class), Arrays.asList(lockName), value,String.valueOf(EXPIRE_TIME))) {
                ThreadUtils.sleep(EXPIRE_TIME);
            }
            log.info("lock {} success. ", lockName);
            return true;
        }
        return false;
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // unused
    }

    @Override
    public Condition newCondition() {
        // unused
        return null;
    }
}

public class LuaScript {

    private LuaScript() {}

    public static final String LUA_LOCK_SCRIPT =
            "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then    " +
                "redis.call('hincrby',KEYS[1],ARGV[1],1)    " +
                "redis.call('expire',KEYS[1],ARGV[2])    " +
                "return 1  " +
            "else   " +
                "return 0 " +
            "end";

    public static final String LUA_UNLOCK_SCRIPT =
            "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 0 then    " +
                "return nil  " +
            "elseif redis.call('HINCRBY',KEYS[1],ARGV[1],-1) == 0 then    " +
                "return redis.call('del',KEYS[1])  " +
            "else    " +
                "return 0 " +
            "end";
}

@Component
@SuppressWarnings("unused")
public class DistributedLockFactory {

    private final String uuid;

    private final StringRedisTemplate redisTemplate;

    public DistributedLockFactory(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.uuid = IdUtil.simpleUUID();
    }

    public Lock getDistributedLock(LockEnum type) {
        return switch (type) {
            // Java17新特性
            case REDIS -> new RedisDistributedLock(redisTemplate, LockNameConstants.REDIS_LOCK_NAME, uuid);
            // TODO 补充
            case ZOOKEEPER, MYSQL -> null;
        };
    }

}

public String sale() {
    String retMessage;

    Lock redisLock = distributedLockFactory.getDistributedLock(LockEnum.REDIS);
    redisLock.lock();
    try {
        //1 查询库存信息
        String result = redisTemplate.opsForValue().get("inventory001");
        //2 判断库存是否足够
        int inventoryNumber = result == null ? 0 : Integer.parseInt(result);
        //3 扣减库存，每次减少一个
        if (inventoryNumber > 0) {
            redisTemplate.opsForValue().set("inventory001", String.valueOf(--inventoryNumber));
            retMessage = "成功卖出一个商品,库存剩余: " + inventoryNumber;
            ThreadUtils.sleep(20);
            testReEntry();
        } else {
            retMessage = "商品卖完了";
        }
        log.info("{} \t 服务端口号: {}", retMessage, port);
    } finally {
        redisLock.unlock();
    }
    return retMessage + "\t" + "服务端口号" + port;
}

private void testReEntry() {
    Lock redisLock = distributedLockFactory.getDistributedLock(LockEnum.REDIS);
    redisLock.lock();
    try
    {
        log.info("测试可重入锁");
    }finally {
        redisLock.unlock();
    }
}