redis分布式鎖詳解Redisson(RedissonClient)

更新時間：2025年11月19日 09:10:28 作者：碼上走人

Redisson提供了多種鎖和實用方法,實現(xiàn)了對數(shù)據(jù)的增刪改查等操作,RedissonClient接口的實現(xiàn)類中,重點介紹了重入鎖、公平鎖和聯(lián)鎖的實現(xiàn)方式,在實際應用中,設置定時過期的分布式鎖需要考慮服務宕機或重啟的問題,可以通過記錄鎖的Set來解決

依賴

<dependency>
      <groupId>org.redisson</groupId>
      <artifactId>redisson</artifactId>
      <version>3.10.7</version>
</dependency>

重入鎖 RedissonLock

重入鎖可以通過Redisson的getLock方法獲取

@Override
public RLock getLock(String name) {
    return new RedissonLock(connectionManager.getCommandExecutor(), name);
}

/**
     * 獲取鎖-同一個線程可重入
     * @param lockKey  鎖的名稱
     * @param waitTime 獲取鎖的等待時間
     * @param leaseTime 鎖的持續(xù)時間
     * @param unit  時間的單位
     * @return 獲取鎖的結果
     */
    public Boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 1. 最常見的使用方法
            //lock.lock();
            // 2. 支持過期解鎖功能,10秒鐘以后自動解鎖, 無需調用unlock方法手動解鎖
            //lock.lock(10, TimeUnit.SECONDS);
            boolean locked = lock.tryLock(waitTime, leaseTime, unit);
            if (locked) lockKeys.add(lockKey);
            return locked;
        } catch (InterruptedException e) {
            System.out.println(String.format("嘗試獲取鎖%s失敗", lockKey));
            e.printStackTrace();
        }
        return Boolean.FALSE;
    }

    /**
     * 解鎖 - 重入的方式，所以同一個線程加了幾次鎖就要釋放幾次鎖
     * @param lockKey 鎖的值
     */
    public boolean unLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判斷鎖是否存在，和是否當前線程加的鎖。
                lock.unlock();
                return lockKeys.remove(lockKey);
            }
        } catch (Exception e) {
            System.out.println(String.format("解鎖鎖%s失敗", lockKey));
            e.printStackTrace();
        }
        return false;
    }

重入鎖的異步執(zhí)行方式

/**
     * 異步獲取鎖-同一個線程可重入
     * @param lockKey  鎖的名稱
     * @param waitTime 獲取鎖的等待時間
     * @param leaseTime 鎖的持續(xù)時間
     * @param unit  時間的單位
     * @return 獲取鎖的結果
     */
    public Boolean tryLockAsync(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 1. 最常見的使用方法
            //lock.lockAsync();
            // 2. 支持過期解鎖功能,10秒鐘以后自動解鎖, 無需調用unlock方法手動解鎖
            //lock.lockAsync(10, TimeUnit.SECONDS);
            RFuture<Boolean> locked = lock.tryLockAsync(waitTime, leaseTime, unit);
            if (locked.get()) lockKeys.add(lockKey);
            return locked.get();
        } catch (InterruptedException | ExecutionException e) {
            System.out.println(String.format("嘗試獲取鎖%s失敗", lockKey));
            e.printStackTrace();
        }
        return Boolean.FALSE;
    }

    /**
     * 解鎖 - 重入的方式，所以同一個線程加了幾次鎖就要釋放幾次鎖
     * @param lockKey 鎖的值
     */
    public boolean unAsyncLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判斷鎖是否存在，和是否當前線程加的鎖。
                RFuture<Void> future = lock.unlockAsync();
                if(future.await(5 * 1000) && future.isSuccess()) {
                    return lockKeys.remove(lockKey);
                }
            }
        } catch (Exception e) {
            System.out.println(String.format("解鎖%s失敗", lockKey));
            e.printStackTrace();
        }
        return false;
    }

公平鎖

改公平鎖是可重入的，在提供了自動過期解鎖功能的同時，保證了當多個Redisson客戶端線程同時請求加鎖時，優(yōu)先分配給先發(fā)出請求的線程。同時也提供了異步的方式。

實現(xiàn)方式參照上一個鎖的實現(xiàn)。

@Override
public RLock getFairLock(String name) {
    return new RedissonFairLock(connectionManager.getCommandExecutor(), name);
}

/**
     * 公平鎖
     *
     * @param lockKey 鎖的名稱
     * @param waitTime 獲取鎖的等待時間
     * @param leaseTime 鎖的持續(xù)時間
     * @param unit 時間的單位
     *
     * @return 獲取鎖的結果
     */
    public Boolean tryFairLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getFairLock(lockKey);
        try {
            // 1. 最常見的使用方法
            //lock.tryLock();
            // 2. 支持過期解鎖功能,10秒鐘以后自動解鎖, 無需調用unlock方法手動解鎖
            //lock.tryLock(10, TimeUnit.SECONDS);
            boolean locked = lock.tryLock(waitTime, leaseTime, unit);
            if (locked)
                lockKeys.add(lockKey);
            return locked;
            /* 異步實現(xiàn)方式
            lock.lockAsync();
            lock.lockAsync(10, TimeUnit.SECONDS);
            RFuture<Boolean> locked = lock.tryLockAsync(waitTime, leaseTime, unit);
            if (locked.get()) lockKeys.add(lockKey);
            return locked.get();*/
        } catch (InterruptedException e) {
            System.out.println(String.format("嘗試獲取鎖%s失敗", lockKey));
            e.printStackTrace();
        }
        return Boolean.FALSE;
    }

    /**
     * 解鎖 - 重入的方式，所以同一個線程加了幾次鎖就要釋放幾次鎖
     *
     * @param lockKey 鎖的值
     */
    public boolean unFairLock(String lockKey) {
        try {
            RLock lock = redissonClient.getFairLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判斷鎖是否存在，和是否當前線程加的鎖。
                lock.unlock();
                return lockKeys.remove(lockKey);

                //異步方式刪除鎖
                /*RFuture<Void> future = lock.unlockAsync();
                if (future.await(5 * 1000) && future.isSuccess()) {
                    return lockKeys.remove(lockKey);
                }*/
            }
        } catch (Exception e) {
            System.out.println(String.format("解鎖%s失敗", lockKey));
            e.printStackTrace();
        }
        return false;
    }

聯(lián)鎖（MultiLock）

Redisson的RedissonMultiLock對象可以將多個RLock對象關聯(lián)為一個聯(lián)鎖，每個RLock對象實例可以來自于不同的Redisson實例。

需要注意的是，在鎖的釋放時，可以單獨釋放Redisson添加的鎖，其他鎖不會釋放依舊存在。

/**
     * 連鎖-只有所有的RedissonClient都鎖成功才算成功
     *
     * @param waitTime 獲取鎖的等待時間
     * @param leaseTime 鎖的持續(xù)時間
     * @param unit 時間的單位
     *
     * @return 獲取鎖的結果
     */
    public Boolean tryMultiLock(RedissonClient redisson1,RedissonClient redisson2, long waitTime, long leaseTime, TimeUnit unit){
        RLock lock1 = redisson1.getLock("zhong:test:lock1");
        RLock lock2 = redisson2.getLock("zhong:test:lock2");
        RLock lock = redissonClient.getMultiLock(lock1, lock2);
        try {
            // 同時加鎖：lock1 lock2 lock3, 所有的鎖都上鎖成功才算成功。
            lock.lock();
            // 嘗試加鎖，最多等待100秒，上鎖以后10秒自動解鎖
            boolean res = lock.tryLock(waitTime, unit);
            return res;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return false;
    }
    /**
     * 連鎖 - 需要遵循誰加的鎖設計釋放鎖，可以單獨釋放自己加的鎖
     *
     */
    public boolean unMultiLock(RedissonClient client ,RedissonClient client1) {
        try {
            List<RLock> locks = new ArrayList<>();
            locks.add(client.getLock("zhong:test:lock1"));
            locks.add(client1.getLock("zhong:test:lock2"));
            RedissonMultiLock lock = new RedissonMultiLock(locks.toArray(new RLock[0]));
            lock.unlock();

            //異步方式刪除鎖
            /*RFuture<Void> future = lock.unlockAsync();
            if (future.await(5 * 1000) && future.isSuccess()) {
                return lockKeys.remove(lockKey);
            }*/
        } catch (Exception e) {
            System.out.println(String.format("解鎖失敗"));
            e.printStackTrace();
            return false;
        }
        return true;
    }

RedissonClient還提供了紅鎖，讀寫鎖等。

在實際應用中我們最常用的分布式鎖一般都是設置定時過期的。

這樣的鎖在實際應用中存在一個問題就是服務宕機或重啟這個鎖在redis上是一直存在的。一旦重啟就可能會導致所有線程無法獲取到鎖。

解決辦法就是在加鎖的時候將鎖記錄到Set里面。釋放鎖的時候將記錄Set中的鎖刪除，在服務停止之前就就根據(jù)set記錄里面的鎖先將歐鎖釋放。

這樣就能保證重啟后能獲取到鎖。實現(xiàn)方式參考DisposableBean的實現(xiàn)方式。