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);
    }
}