Redis 分散式鎖

語言: CN / TW / HK

小知識,大挑戰!本文正在參與“程式設計師必備小知識”創作活動。

本文已參與「掘力星計劃>」,贏取創作大禮包,挑戰創作激勵金。

概述

本文主要是講述分散式鎖的實現和程式碼解析。

Redis 分散式鎖

大家專案中都會使用到分散式鎖把,通常用來做資料的有序操作場景,比如一筆訂單退款(如果可以退多次的情況)。或者使用者多端下單。

Maven 依賴

我主要是基於 Spring-Boot 2.1.2 + Jedis 進行實現 ```xml

4.0.0

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

```

配置檔案

application.properties 配置檔案內容如下: ```shell 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 ```

介面定義

介面定義,對於鎖我們核心其實就連個方法 lockunlock. ```java 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 邏輯的話,會通過 自旋 的方式重試 ```java // 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;
}

}

```

測試程式碼

最後再來看看如何使用吧. (下面是一個模擬秒殺的場景) ```java @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 鎖的一種簡單的實現方式,基於 jedis 實現了鎖的重試操作。 但是缺點還是有的,不支援鎖的自動續期,鎖的重入,以及公平性(目前通過自旋的方式實現,相當於是非公平的方式)。

參考文件

  • https://github.com/zhengsh/redis-lock