Redis實現分散式鎖的五種方法詳解

2022-06-14 10:00:16

1. 單機資料一致性

單機資料一致性架構如下圖所示：多個可客戶存取同一個伺服器，連線同一個資料庫。

場景描述：使用者端模擬購買商品過程，在Redis中設定庫存總數剩100個，多個使用者端同時並行購買。

@RestController
public class IndexController1 {

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy1")
    public String index(){
        // Redis中存有goods:001號商品，數量為100
        String result = template.opsForValue().get("goods:001");
        // 獲取到剩餘商品數
        int total = result == null ? 0 : Integer.parseInt(result);
        if( total > 0 ){
            // 剩餘商品數大於0 ，則進行扣減
            int realTotal = total -1;
            // 將商品數回寫資料庫
            template.opsForValue().set("goods:001",String.valueOf(realTotal));
            System.out.println("購買商品成功，庫存還剩："+realTotal +"件， 伺服器埠為8001");
            return "購買商品成功，庫存還剩："+realTotal +"件， 伺服器埠為8001";
        }else{
            System.out.println("購買商品失敗，伺服器埠為8001");
        }
        return "購買商品失敗，伺服器埠為8001";
    }
}

使用Jmeter模擬高並行場景，測試結果如下：

測試結果出現多個使用者購買同一商品，發生了資料不一致問題！

解決辦法：單體應用的情況下，對並行的操作進行加鎖操作，保證對資料的操作具有原子性

synchronized
ReentrantLock

@RestController
public class IndexController2 {
// 使用ReentrantLock鎖解決單體應用的並行問題
Lock lock = new ReentrantLock();

@Autowired
StringRedisTemplate template;

@RequestMapping("/buy2")
public String index() {

    lock.lock();
    try {
        String result = template.opsForValue().get("goods:001");
        int total = result == null ? 0 : Integer.parseInt(result);
        if (total > 0) {
            int realTotal = total - 1;
            template.opsForValue().set("goods:001", String.valueOf(realTotal));
            System.out.println("購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001");
            return "購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001";
        } else {
            System.out.println("購買商品失敗，伺服器埠為8001");
        }
    } catch (Exception e) {
        lock.unlock();
    } finally {
        lock.unlock();
    }
    return "購買商品失敗，伺服器埠為8001";
}
}

2. 分散式資料一致性

上面解決了單體應用的資料一致性問題，但如果是分散式架構部署呢，架構如下：

提供兩個服務，埠分別為8001、8002，連線同一個Redis服務，在服務前面有一臺Nginx作為負載均衡

兩臺服務程式碼相同，只是埠不同

將8001、8002兩個服務啟動，每個服務依然用ReentrantLock加鎖，用Jmeter做並行測試，發現會出現資料一致性問題！

3. Redis實現分散式鎖

3.1 方式一

取消單機鎖，下面使用redis的set命令來實現分散式加鎖

SET KEY VALUE [EX seconds] [PX milliseconds] [NX|XX]

EX seconds 設定指定的到期時間(以秒為單位)
PX milliseconds 設定指定的到期時間(以毫秒為單位)
NX 僅在鍵不存在時設定鍵
XX 只有在鍵已存在時才設定

@RestController
public class IndexController4 {

    // Redis分散式鎖的key
    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy4")
    public String index(){

        // 每個人進來先要進行加鎖，key值為"good_lock"，value隨機生成
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 加鎖
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value);
            // 加鎖失敗
            if(!flag){
                return "搶鎖失敗！";
            }
            System.out.println( value+ " 搶鎖成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                // 如果在搶到所之後，刪除鎖之前，發生了異常，鎖就無法被釋放，
                // 釋放鎖操作不能在此操作，要在finally處理
				// template.delete(REDIS_LOCK);
                System.out.println("購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001");
                return "購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001";
            } else {
                System.out.println("購買商品失敗，伺服器埠為8001");
            }
            return "購買商品失敗，伺服器埠為8001";
        }finally {
            // 釋放鎖
            template.delete(REDIS_LOCK);
        }
    }
}

上面的程式碼，可以解決分散式架構中資料一致性問題。但再仔細想想，還是會有問題，下面進行改進。

3.2 方式二（改進方式一）

在上面的程式碼中，如果程式在執行期間，部署了微服務jar包的機器突然掛了，程式碼層面根本就沒有走到finally程式碼塊，也就是說在宕機前，鎖並沒有被刪除掉，這樣的話，就沒辦法保證解鎖

所以，這裡需要對這個key加一個過期時間，Redis中設定過期時間有兩種方法：

template.expire(REDIS_LOCK,10, TimeUnit.SECONDS)
template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS)

第一種方法需要單獨的一行程式碼，且並沒有與加鎖放在同一步操作，所以不具備原子性，也會出問題

第二種方法在加鎖的同時就進行了設定過期時間，所有沒有問題，這裡採用這種方式

調整下程式碼，在加鎖的同時，設定過期時間：

// 為key加一個過期時間，其餘程式碼不變
Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK,value,10L,TimeUnit.SECONDS);

這種方式解決了因服務突然宕機而無法釋放鎖的問題。但再仔細想想，還是會有問題，下面進行改進。

3.3 方式三（改進方式二）

方式二設定了key的過期時間，解決了key無法刪除的問題，但問題又來了

上面設定了key的過期時間為10秒，如果業務邏輯比較複雜，需要呼叫其他微服務，處理時間需要15秒（模擬場

景，別較真），而當10秒鐘過去之後，這個key就過期了，其他請求就又可以設定這個key，此時如果耗時15秒

的請求處理完了，回來繼續執行程式，就會把別人設定的key給刪除了，這是個很嚴重的問題！

所以，誰上的鎖，誰才能刪除

@RestController
public class IndexController6 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy6")
    public String index(){

        // 每個人進來先要進行加鎖，key值為"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 為key加一個過期時間
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);

            // 加鎖失敗
            if(!flag){
                return "搶鎖失敗！";
            }
            System.out.println( value+ " 搶鎖成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此處需要呼叫其他微服務，處理時間較長。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001");
                return "購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001";
            } else {
                System.out.println("購買商品失敗，伺服器埠為8001");
            }
            return "購買商品失敗，伺服器埠為8001";
        }finally {
            // 誰加的鎖，誰才能刪除！！！！
            if(template.opsForValue().get(REDIS_LOCK).equals(value)){
                template.delete(REDIS_LOCK);
            }
        }
    }
}

這種方式解決了因服務處理時間太長而釋放了別人鎖的問題。這樣就沒問題了嗎？

3.4 方式四（改進方式三）

在上面方式三下，規定了誰上的鎖，誰才能刪除，但finally快的判斷和del刪除操作不是原子操作，並行的時候也會出問題，並行嘛，就是要保證資料的一致性，保證資料的一致性，最好要保證對資料的操作具有原子性。

在Redis的set命令介紹中，最後推薦Lua指令碼進行鎖的刪除，地址

@RestController
public class IndexController7 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy7")
    public String index(){

        // 每個人進來先要進行加鎖，key值為"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 為key加一個過期時間
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
            // 加鎖失敗
            if(!flag){
                return "搶鎖失敗！";
            }
            System.out.println( value+ " 搶鎖成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此處需要呼叫其他微服務，處理時間較長。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001");
                return "購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001";
            } else {
                System.out.println("購買商品失敗，伺服器埠為8001");
            }
            return "購買商品失敗，伺服器埠為8001";
        }finally {
            // 誰加的鎖，誰才能刪除，使用Lua指令碼，進行鎖的刪除

            Jedis jedis = null;
            try{
                jedis = RedisUtils.getJedis();

                String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
                        "then " +
                        "return redis.call('del',KEYS[1]) " +
                        "else " +
                        "   return 0 " +
                        "end";

                Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
                if("1".equals(eval.toString())){
                    System.out.println("-----del redis lock ok....");
                }else{
                    System.out.println("-----del redis lock error ....");
                }
            }catch (Exception e){

            }finally {
                if(null != jedis){
                    jedis.close();
                }
            }
        }
    }
}

3.5 方式五（改進方式四）

在方式四下，規定了誰上的鎖，誰才能刪除，並且解決了刪除操作沒有原子性問題。但還沒有考慮快取續命，以及Redis叢集部署下，非同步複製造成的鎖丟失：主節點沒來得及把剛剛set進來這條資料給從節點，就掛了。所以直接上RedLock的Redisson落地實現。

@RestController
public class IndexController8 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @Autowired
    Redisson redisson;

    @RequestMapping("/buy8")
    public String index(){

        RLock lock = redisson.getLock(REDIS_LOCK);
        lock.lock();

        // 每個人進來先要進行加鎖，key值為"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此處需要呼叫其他微服務，處理時間較長。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001");
                return "購買商品成功，庫存還剩：" + realTotal + "件， 伺服器埠為8001";
            } else {
                System.out.println("購買商品失敗，伺服器埠為8001");
            }
            return "購買商品失敗，伺服器埠為8001";
        }finally {
            if(lock.isLocked() && lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}