文章目錄

一、項目Demo

二、Redisson 之 Redlock

Redisson實現了分佈式和可擴展的Java數據結構，和Jedis相比，功能較爲簡單，不支持字符串操作，不支持排序、事務、管道、分區等Redis特性。Redisson的宗旨是促進使用者對Redis的關注分離，從而讓使用者能夠將精力更集中地放在處理業務邏輯上。

一、項目Demo

1.1 項目依賴

<!-- 單元測試 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- redisson -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.10.6</version>
</dependency>

1.2 項目配置-redis

spring:
  redis:
    host: 47.98.178.84
    port: 6379
    database: 0
    password: password
    timeout: 60s

1.3 Redisson的配置類RedissonConfig

@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private String port;
    @Value("${spring.redis.password}")
    private String password;

    /**
     * RedissonClient,單機模式
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        return Redisson.create(config);
    }

    @Bean
    public RedissonLocker redissonLocker(RedissonClient redissonClient){
        RedissonLocker locker = new RedissonLocker(redissonClient);
        //設置LockUtil的鎖處理對象
        LockUtil.setLocker(locker);
        return locker;
    }
}

1.4 定義一個Loker接口，用於分佈式鎖的一些操作

主要是爲了考慮擴展，本文用redisson實現，同樣的Loker接口，也可用redis實現分佈式鎖，詳見另一篇文章。

public interface Locker {
    /**
     * 獲取鎖，如果鎖不可用，則當前線程處於休眠狀態，直到獲得鎖爲止。
     *
     * @param lockKey
     */
    void lock(String lockKey);

    /**
     * 釋放鎖
     *
     * @param lockKey
     */
    void unlock(String lockKey);

    /**
     * 帶超時的鎖: 超過加鎖時間後自動解鎖
     *
     * @param lockKey
     * @param timeout : 秒
     */
    void lock(String lockKey, int timeout);

    /**
     * 帶超時的鎖: 超過加鎖時間後自動解鎖
     *
     * @param lockKey
     * @param unit
     * @param timeout
     */
    void lock(String lockKey, TimeUnit unit, int timeout);

    /**
     * 嘗試獲取鎖，獲取到立即返回true,未獲取到立即返回false
     *
     * @param lockKey
     * @return
     */
    boolean tryLock(String lockKey);

    /**
     * 嘗試獲取鎖，在等待時間內獲取到鎖則返回true,否則返回false,如果獲取到鎖，則要麼執行完後程序釋放鎖，
     * 要麼在給定的超時時間leaseTime後釋放鎖
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     */
    boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
            throws InterruptedException;

    /**
     * 鎖是否被任意一個線程鎖持有
     *
     * @param lockKey
     * @return
     */
    boolean isLocked(String lockKey);
}

1.5 基於Redisson的實現類RedissonLocker

public class RedissonLocker implements Locker{

    private RedissonClient redissonClient;

    public RedissonLocker(RedissonClient redissonClient) {
        super();
        this.redissonClient = redissonClient;
    }

    
    public void lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
    }


    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    
    public void lock(String lockKey, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
    }

    
    public void lock(String lockKey, TimeUnit unit, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
    }

    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    
    public boolean tryLock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock();
    }

    
    public boolean tryLock(String lockKey, long waitTime, long leaseTime,
                           TimeUnit unit) throws InterruptedException{
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock(waitTime, leaseTime, unit);
    }

    
    public boolean isLocked(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.isLocked();
    }
}

1.6 定義一個分佈式鎖工具類LockUtil

public class LockUtil {
    private static Locker locker;

    /**
     * 設置工具類使用的locker
     * @param locker
     */
    public static void setLocker(Locker locker) {
        LockUtil.locker = locker;
    }

    /**
     * 獲取鎖
     * @param lockKey
     */
    public static void lock(String lockKey) {
        locker.lock(lockKey);
    }

    /**
     * 釋放鎖
     * @param lockKey
     */
    public static void unlock(String lockKey) {
        locker.unlock(lockKey);
    }

    /**
     * 獲取鎖，超時釋放
     * @param lockKey
     * @param timeout
     */
    public static void lock(String lockKey, int timeout) {
        locker.lock(lockKey, timeout);
    }

    /**
     * 獲取鎖，超時釋放，指定時間單位
     * @param lockKey
     * @param unit
     * @param timeout
     */
    public static void lock(String lockKey, TimeUnit unit, int timeout) {
        locker.lock(lockKey, unit, timeout);
    }

    /**
     * 嘗試獲取鎖，獲取到立即返回true,獲取失敗立即返回false
     * @param lockKey
     * @return
     */
    public static boolean tryLock(String lockKey) {
        return locker.tryLock(lockKey);
    }

    /**
     * 嘗試獲取鎖，在給定的waitTime時間內嘗試，獲取到返回true,獲取失敗返回false,獲取到後再給定的leaseTime時間超時釋放
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     * @throws InterruptedException
     */
    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                                  TimeUnit unit) throws InterruptedException {
        return locker.tryLock(lockKey, waitTime, leaseTime, unit);
    }

    /**
     * 鎖釋放被任意一個線程持有
     * @param lockKey
     * @return
     */
    public static boolean isLocked(String lockKey) {
        return locker.isLocked(lockKey);
    }
}

1.7 單元測試

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

    private static final Logger logger = LoggerFactory.getLogger(LockerTest.class);

    @Test
    public void testLock() {
        LockUtil.lock("hello");
        logger.info("獲取了鎖");
        try {
            //TODO 幹事情
        } catch (Exception e) {
            //異常處理
        }finally{
            //釋放鎖
            LockUtil.unlock("hello");
            logger.info("釋放鎖");
        }
    }
}

1.8 源碼

SpringBoot集成Redisson分佈式鎖

二、Redisson 之 Redlock

一頓猛操作後，我們來看看它的優勢。

2.1 基於Redis命令的分佈式鎖

我們都知道Redis分佈式鎖大部分人都會想到：

- 獲取鎖（unique_value可以是UUID等）
SET resource_name unique_value NX PX 30000

- 釋放鎖（lua腳本中，一定要比較value，防止誤解鎖）
if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

這種實現方式有3大要點：

set命令要用set key value px milliseconds nx；
value要具有唯一性；
釋放鎖時要驗證value值，不能誤解鎖；

同時，他也存在一個很大的問題：它加鎖時只作用在一個Redis節點上，即使Redis通過sentinel保證高可用，如果這個master節點由於某些原因發生了主從切換，那麼就會出現鎖丟失的情況：

在Redis的master節點上拿到了鎖；
但是這個加鎖的key還沒有同步到slave節點；
master故障，發生故障轉移，slave節點升級爲master節點；

正因爲如此，Redis作者antirez基於分佈式環境下提出了一種更高級的分佈式鎖的實現方式：Redlock

2.2 Redlock實現

在Redis的分佈式環境中，我們假設有N個Redis master。這些節點完全互相獨立，不存在主從複製或者其他集羣協調機制。我們確保將在N個實例上使用與在Redis單實例下相同方法獲取和釋放鎖。爲了取到鎖，客戶端應該執行以下操作:

獲取當前Unix時間，以毫秒爲單位。
依次嘗試從N個實例，使用相同的key和具有唯一性的value（例如UUID）獲取鎖。當向Redis請求獲取鎖時，客戶端應該設置一個網絡連接和響應超時時間，這個超時時間應該小於鎖的失效時間。例如你的鎖自動失效時間爲10秒，則超時時間應該在5-50毫秒之間。這樣可以避免服務器端Redis已經掛掉的情況下，客戶端還在死死地等待響應結果。如果服務器端沒有在規定時間內響應，客戶端應該儘快嘗試去另外一個Redis實例請求獲取鎖。
客戶端使用當前時間減去開始獲取鎖時間（步驟1記錄的時間）就得到獲取鎖使用的時間。當且僅當從大多數（N/2+1 個節點）的Redis節點都取到鎖，並且使用的時間小於鎖失效時間時，鎖纔算獲取成功。
如果取到了鎖，key的真正有效時間等於有效時間減去獲取鎖所使用的時間。
如果因爲某些原因，獲取鎖失敗（沒有在至少N/2+1個Redis實例取到鎖或者取鎖時間已經超過了有效時間），客戶端應該在所有的Redis實例上進行解鎖（即便某些Redis實例根本就沒有加鎖成功，防止某些節點獲取到鎖但是客戶端沒有得到響應而導致接下來的一段時間不能被重新獲取鎖）。

2.3 Redlock源碼

2.3.1 唯一ID

實現分佈式鎖的一個非常重要的點就是set的value要具有唯一性，redisson的value是怎樣保證value的唯一性呢？答案是**UUID+threadId**。源碼在Redisson.java和RedissonLock.java中：

protected final UUID id = UUID.randomUUID();
String getLockName(long threadId) {
    return id + ":" + threadId;
}

2.3.2 獲取鎖

獲取鎖的代碼爲redLock.tryLock()或者redLock.tryLock(500, 10000, TimeUnit.MILLISECONDS)，兩者的最終核心源碼都是下面這段代碼，只不過前者獲取鎖的默認租約時間（leaseTime）是LOCK_EXPIRATION_INTERVAL_SECONDS，即30s：

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    internalLockLeaseTime = unit.toMillis(leaseTime);
    // 獲取鎖時需要在redis實例上執行的lua命令
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
              // 首先分佈式鎖的KEY不能存在，如果確實不存在，那麼執行hset命令（hset REDLOCK_KEY uuid+threadId 1），並通過pexpire設置失效時間（也是鎖的租約時間）
              "if (redis.call('exists', KEYS[1]) == 0) then " +
                  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              // 如果分佈式鎖的KEY已經存在，並且value也匹配，表示是當前線程持有的鎖，那麼重入次數加1，並且設置失效時間
              "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                  "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              // 獲取分佈式鎖的KEY的失效時間毫秒數
              "return redis.call('pttl', KEYS[1]);",
              // 這三個參數分別對應KEYS[1]，ARGV[1]和ARGV[2]
                Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}

獲取鎖的命令:

KEYS[1]就是Collections.singletonList(getName())，表示分佈式鎖的key，即REDLOCK_KEY；
ARGV[1]就是internalLockLeaseTime，即鎖的租約時間，默認30s；
ARGV[2]就是getLockName(threadId)，是獲取鎖時set的唯一值，即UUID+threadId。

2.3.2 釋放鎖

釋放鎖的代碼爲redLock.unlock()，核心源碼如下：

protected RFuture<Boolean> unlockInnerAsync(long threadId) {
    // 釋放鎖時需要在redis實例上執行的lua命令
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
            // 如果分佈式鎖KEY不存在，那麼向channel發佈一條消息
            "if (redis.call('exists', KEYS[1]) == 0) then " +
                "redis.call('publish', KEYS[2], ARGV[1]); " +
                "return 1; " +
            "end;" +
            // 如果分佈式鎖存在，但是value不匹配，表示鎖已經被佔用，那麼直接返回
            "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                "return nil;" +
            "end; " +
            // 如果就是當前線程佔有分佈式鎖，那麼將重入次數減1
            "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
            // 重入次數減1後的值如果大於0，表示分佈式鎖有重入過，那麼只設置失效時間，還不能刪除
            "if (counter > 0) then " +
                "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                "return 0; " +
            "else " +
                // 重入次數減1後的值如果爲0，表示分佈式鎖只獲取過1次，那麼刪除這個KEY，併發布解鎖消息
                "redis.call('del', KEYS[1]); " +
                "redis.call('publish', KEYS[2], ARGV[1]); " +
                "return 1; "+
            "end; " +
            "return nil;",
            // 這5個參數分別對應KEYS[1]，KEYS[2]，ARGV[1]，ARGV[2]和ARGV[3]
            Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId));

}

Redis 作爲分佈式鎖(一)：SpringBoot集成Redisson分佈式鎖

文章目錄

一、項目Demo

1.1 項目依賴

1.2 項目配置-redis

1.3 Redisson的配置類RedissonConfig

1.4 定義一個Loker接口，用於分佈式鎖的一些操作

1.5 基於Redisson的實現類RedissonLocker

1.6 定義一個分佈式鎖工具類LockUtil

1.7 單元測試

1.8 源碼

二、Redisson 之 Redlock

2.1 基於Redis命令的分佈式鎖

2.2 Redlock實現

2.3 Redlock源碼

2.3.1 唯一ID

2.3.2 獲取鎖

2.3.2 釋放鎖

Mac 安裝與配置 Zookeeper

Spring Boot 系列：配置 Swagger2

Spring Boot 系列：配置 Redis

Mybatis系列：逆向工程自動生成代碼

Spring Boot 系列：處理跨域請求

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結