Redis의 분산 잠금에 대한 심층 분석

이 글은 주로 Redis의 분산 잠금 구현 및 코드 분석에 대해 소개합니다.

Redis 분산 잠금

분산 잠금 핸들은 일반적으로 주문 환불(여러 번 환불이 가능한 경우)과 같은 데이터의 순차적인 작업 시나리오에 사용됩니다. 또는 사용자가 여러 단말기를 통해 주문합니다. [관련 추천 : Redis 영상 튜토리얼]

Maven 의존성

주로 Spring-Boot 2.1.2 + JedisSpring-Boot 2.1.2 + Jedis 进行实现

<?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">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
    </parent>

    <groupId>cn.edu.cqvie</groupId>
    <artifactId>redis-lock</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <redis.version>2.9.0</redis.version>
        <spring-test.version>5.0.7</spring-test.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${redis.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>log4j-over-slf4j</artifactId>
        </dependency>

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

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

</project>

配置文件

application.properties 配置文件内容如下：

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.timeout=30000
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.min-idle=2
spring.redis.jedis.pool.max-idle=4


logging.level.root=INFO

接口定义

接口定义，对于锁我们核心其实就连个方法 lock 和 unlock.

public interface RedisLock {

    long TIMEOUT_MILLIS = 30000;

    int RETRY_MILLIS = 30000;

    long SLEEP_MILLIS = 10;

    boolean tryLock(String key);

    boolean lock(String key);

    boolean lock(String key, long expire);

    boolean lock(String key, long expire, long retryTimes);

    boolean unlock(String key);
}

分布式锁实现

我的实现方式是通过 setnx 方式实现了，如果存在 tryLock 逻辑的话，会通过 自旋 的方式重试

// AbstractRedisLock.java 抽象类
public abstract class AbstractRedisLock implements RedisLock {

    @Override
    public boolean lock(String key) {
        return lock(key, TIMEOUT_MILLIS);
    }

    @Override
    public boolean lock(String key, long expire) {
        return lock(key, TIMEOUT_MILLIS, RETRY_MILLIS);
    }
}

// 具体实现
@Component
public class RedisLockImpl extends AbstractRedisLock {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    private ThreadLocal<String> threadLocal = new ThreadLocal<String>();
    private static final String UNLOCK_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();

    }

    @Override
    public boolean tryLock(String key) {
        return tryLock(key, TIMEOUT_MILLIS);
    }

    public boolean tryLock(String key, long expire) {
        try {
            return !StringUtils.isEmpty(redisTemplate.execute((RedisCallback<String>) connection -> {
                JedisCommands commands = (JedisCommands) connection.getNativeConnection();
                String uuid = UUID.randomUUID().toString();
                threadLocal.set(uuid);
                return commands.set(key, uuid, "NX", "PX", expire);
            }));
        } catch (Throwable e) {
            logger.error("set redis occurred an exception", e);
        }
        return false;
    }

    @Override
    public boolean lock(String key, long expire, long retryTimes) {
        boolean result = tryLock(key, expire);

        while (!result && retryTimes-- > 0) {
            try {
                logger.debug("lock failed, retrying...{}", retryTimes);
                Thread.sleep(SLEEP_MILLIS);
            } catch (InterruptedException e) {
                return false;
            }
            result = tryLock(key, expire);
        }
        return result;
    }

    @Override
    public boolean unlock(String key) {
        try {
            List<String> keys = Collections.singletonList(key);
            List<String> args = Collections.singletonList(threadLocal.get());
            Long result = redisTemplate.execute((RedisCallback<Long>) connection -> {
                Object nativeConnection = connection.getNativeConnection();

                if (nativeConnection instanceof JedisCluster) {
                    return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, args);
                }
                if (nativeConnection instanceof Jedis) {
                    return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, args);
                }
                return 0L;
            });
            return result != null && result > 0;
        } catch (Throwable e) {
            logger.error("unlock occurred an exception", e);
        }
        return false;
    }
}

测试代码

最后再来看看如何使用吧. (下面是一个模拟秒杀的场景)

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisLockImplTest {

    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private RedisLock redisLock;
    @Autowired
    private StringRedisTemplate redisTemplate;
    private ExecutorService executors = Executors.newScheduledThreadPool(8);

    @Test
    public void lock() {
        // 初始化库存
        redisTemplate.opsForValue().set("goods-seckill", "10");
        List<Future> futureList = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            futureList.add(executors.submit(this::seckill));
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 等待结果，防止主线程退出
        futureList.forEach(action -> {
            try {
                action.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });

    }

    public int seckill() {
        String key = "goods";
        try {
            redisLock.lock(key);
            int num = Integer.valueOf(Objects.requireNonNull(redisTemplate.opsForValue().get("goods-seckill")));
            if (num > 0) {
                redisTemplate.opsForValue().set("goods-seckill", String.valueOf(--num));
                logger.info("秒杀成功，剩余库存：{}", num);
            } else {
                logger.error("秒杀失败，剩余库存：{}", num);
            }
            return num;
        } catch (Throwable e) {
            logger.error("seckill exception", e);
        } finally {
            redisLock.unlock(key);
        }
        return 0;
    }
}

总结

本文是 Redis 锁的一种简单的实现方式，基于 jedisrrreee를 기반으로 구현하고 있습니다.

구성 파일

🎜🎜application.properties 구성 파일의 내용은 다음과 같습니다. 🎜rrreee🎜🎜🎜인터페이스 정의🎜🎜🎜🎜인터페이스 정의, 코어 잠금에 대한 내용은 다음과 같습니다. 실제로는 잠금 및 잠금 해제 메서드 하나만 있습니다.🎜rrreee🎜🎜🎜분산 잠금 구현🎜🎜🎜🎜내 구현은 setnx를 통해 이루어집니다. tryLock이 있는 경우. > logic 그렇다면 spin에 의해 재시도됩니다🎜rrreee🎜🎜🎜테스트 코드🎜🎜🎜🎜마지막으로 어떻게 사용하는지 살펴보겠습니다. (다음은 시뮬레이션된 플래시 세일 시나리오입니다.)🎜rrreee🎜 🎜 요약 🎜🎜🎜이 글은 jedis를 기반으로 잠금 재시도 작업을 구현하는 Redis 잠금의 간단한 구현입니다. 그러나 여전히 단점이 있습니다. 잠금 자동 갱신, 잠금 재진입 및 공정성(현재는 불공정한 방법에 해당하는 스핀을 통해 구현됨)을 지원하지 않습니다. 🎜🎜더 많은 프로그래밍 관련 지식을 보려면 🎜프로그래밍 소개🎜를 방문하세요! ! 🎜

위 내용은 Redis의 분산 잠금에 대한 심층 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!