基于Redis的SETNX实现分布式锁

原创转载请注明出处：https://www.cnblogs.com/agilestyle/p/13200032.html

 

原理

SET key value [NX] [XX] [EX <seconds>] [PX [millseconds]]

必选参数说明 

• SET：命令
• key：待设置的key
• value: 设置的key的value

可选参数说明

• NX：表示key不存在才设置，如果存在则返回NULL
• XX：表示key存在时才设置，如果不存在则返回NULL
• EX seconds：设置过期时间，过期时间精确为秒
• PX millseconds：设置过期时间，过期时间精确为毫秒

以上set 代替了 setnx + expire 需要分2次执行命令操作的方式，保证了原子性。

如果setnx 返回ok 说明拿到了锁；如果setnx 返回 nil，说明拿锁失败，被其他线程占用。

 

Project Directory

 

Maven Dependency

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.8.RELEASE</version>
        <relativePath/>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <groupId>org.fool.redis</groupId>
    <artifactId>redis-lock-setnx</artifactId>
    <version>1.0-SNAPSHOT</version>

    <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>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

 

src/main/resources

application.properties

spring.application.name=redis-lock-setnx
server.port=8888

logging.level.org.fool.redis=debug

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0
spring.redis.password=
spring.redis.timeout=2000
spring.redis.pool.max-active=10
spring.redis.pool.max-wait=1000
spring.redis.pool.max-idle=10
spring.redis.pool.min-idle=5
spring.redis.pool.num-tests-per-eviction-run=1024
spring.redis.pool.time-between-eviction-runs-millis=30000
spring.redis.pool.min-evictable-idle-time-millis=60000
spring.redis.pool.soft-min-evictable-idle-time-millis=10000
spring.redis.pool.test-on-borrow=true
spring.redis.pool.test-while-idle=true
spring.redis.pool.block-when-exhausted=false

 

src/main/java

Application.java

package org.fool.redis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

 

JsonUtils.java

package org.fool.redis.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;
import java.util.Map;

public class JsonUtils {
    private static final ObjectMapper MAPPER = new ObjectMapper();

    public static String objectToJson(Object data) {
        try {
            String string = MAPPER.writeValueAsString(data);
            return string;
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    public static <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
        JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);

        try {
            List<T> list = MAPPER.readValue(jsonData, javaType);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    public static <K, V> Map<K, V> jsonToMap(String jsonData, Class<K> keyType, Class<V> valueType) {
        JavaType javaType = MAPPER.getTypeFactory().constructMapType(Map.class, keyType, valueType);

        try {
            Map<K, V> map = MAPPER.readValue(jsonData, javaType);
            return map;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

 

OrderRequest.java

package org.fool.redis.controller;

import lombok.Data;

@Data
public class OrderRequest {
    private Integer id;
    private Integer productId;
    private Integer price;
    private Integer userId;
    private Integer tradeId;
    private Integer tradeStatus;
}

 

OrderController.java

package org.fool.redis.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

@RestController
@Slf4j
public class OrderController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @PostMapping(value = "/createOrder", produces = "application/json;charset=utf-8")
    public String createOrder(@RequestBody OrderRequest request) {

        String json = JsonUtils.objectToJson(request);
        String md5 = DigestUtils.md5DigestAsHex(json.getBytes()).toUpperCase();

        /*
         * setIfAbsent <=> SET key value [NX] [XX] [EX <seconds>] [PX [millseconds]]
         * set expire time 5 mins
         */
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(md5, "1", 60 * 5, TimeUnit.SECONDS);
        if (flag) {
            // lock success, start to handle business
            log.debug("{} lock success, start to handle business", md5);
            try {
                //mock to handle business
                Thread.sleep(1000 * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //end to handle business, need to unlock
            stringRedisTemplate.delete(md5);
            log.debug("{} unlock success，end to handle business", md5);
            return "SUCCESS";
        } else {
            log.debug("{} lock failure", md5);
            return "try again later";
        }
    }
}

 

Test

 

Console Output

 

---

欢迎点赞关注和收藏