redis分布式锁学习之路1-RedisTemplate实现分布式锁

1. pom文件

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
</dependencies>

2. SpringBoot配置.

server:
  port: 8081
# Redis数据库索引（默认为0）
spring:
  redis:
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码（默认为空）
    #password:
    jedis:
      pool:
        max-idle: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        # 连接池中的最大空闲连接
        # 连接池中的最小空闲连接
        min-idle: 0
    # 连接超时时间（毫秒）
    timeout: 100000

3. 话不多说,直接代码撸起

 

package com.hy.redis.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 *
 * redis 加锁的方式 实现高并发小分布式事务的处理
 *
 * @author huheng
 * @date 2020/08/03
 **/
@Controller
public class DeductStockController {

    @Resource
    private RedisTemplate redisTemplate;

    @RequestMapping("/deduct-stock")
    @ResponseBody
    public String deductStock() {
        String clientId = UUID.randomUUID().toString();
        String lockKey = "lockKey";
        try {
            // 先加锁
            Boolean flag = redisTemplate.opsForValue().setIfAbsent("lockKey", clientId, 10, TimeUnit.SECONDS);

            // 加锁成功 执行扣除库存
            if (flag) {
                // 执行定时器 判断锁是否存在 存在 则延长失效时间
                timer(lockKey, clientId);

                // 读取库存
                Integer stock = (Integer) redisTemplate.opsForValue().get("stock");
                if (stock != null && stock > 0) {
                    redisTemplate.opsForValue().set("stock", stock - 1);
                    System.out.println("抢购成功--扣除库存成功" + "-----原库存:" + stock + "剩余库存:" + (stock - 1));
                }
            }
        } finally {
            // 释放锁
            String verfiy = (String) redisTemplate.opsForValue().get(lockKey);
            // 判断是否为当前线程加的锁
            if (Objects.equals(verfiy, clientId)) {
                redisTemplate.delete(lockKey);
            }
        }
        return "end";
    }

    /**
     * 5秒钟一次
     * @param lockKey
     * @param clientId
     */
    @Async
    public void timer(String lockKey, String clientId) {
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        // 参数：1、任务体 2、首次执行的延时时间
        //      3、任务执行间隔 4、间隔时间单位
        service.scheduleAtFixedRate(()->{
            String result = (String) redisTemplate.opsForValue().get(lockKey);
            if (result != null && result.equals(clientId)) {
                redisTemplate.expire(lockKey, 10 , TimeUnit.SECONDS);
            } else {
                service.shutdown();
            }
        }, 0, 5, TimeUnit.SECONDS);
    }
}