redis分散式鎖如何實現原理-Redis-PHP中文網

redis分散式鎖如何實現原理

分散式鎖定，是控制分散式系統之間同步存取共用資源的一種方式。

在分散式系統中，常常需要協調他們的動作。如果不同的系統或是同一個系統的不同主機之間共享了一個或一組資源，那麼訪問這些資源的時候，往往需要互斥來防止彼此幹擾來保證一致性，在這種情況下，便需要使用到分散式鎖。

使用setnx、getset、expire、del這4個redis指令實作 （建議學習：Redis影片教學）

setnx 是「SET if Not eXists’(如果不存在，則SET)的簡寫。指令格式：SETNX key value；使用：僅在鍵 key 不存在的情況下，將鍵 key 的值設為 value 。若鍵 key 已經存在，則 SETNX 指令不做任何動作。傳回值：指令在設定成功時傳回 1 ，設定失敗時傳回 0 。

getset 指令格式：GETSET key value，將鍵 key 的值設為 value ，並傳回鍵 key 在被設定之前的舊的value。傳回值：如果鍵 key 沒有舊值，也也就是是說，鍵 key 在被設定之前並不存在，那麼指令傳回 nil 。當鍵 key 存在但不是字串類型時，命令會傳回一個錯誤。

expire 指令格式：EXPIRE key seconds，使用：為給定 key 設定生存時間，當 key 過期時(生存時間為 0 )，它會被自動刪除。傳回值：設定成功返回 1 。當 key 不存在或無法為 key 設定生存時間時(例如在低於 2.1.3 版本的 Redis 中你嘗試更新 key 的生存時間)，返回 0 。

del 指令格式：DEL key [key …]，使用：刪除給定的一個或多個 key ，不存在的 key 會被忽略。傳回值：被刪除 key 的數量。

Redis實作分散式鎖定的原理：

1.透過setnx(lock_timeout)實現，如果設定了鎖定回傳1，已經有值沒有設定成功回傳0

2.死鎖問題：透過實作來判斷是否過期，如果已經過期，取得到過期時間get(lockKey)，然後getset(lock_timeout)判斷是否和get相同，相同則證明已經加鎖成功，因為可能導致多線程同時執行getset(lock_timeout)方法，這可能導致多線程都只需getset後，對於判斷加鎖成功的線程，再加expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS)過期時間，防止多個執行緒同時疊加時間，導致鎖定時效時間翻倍

redis分散式鎖如何實現原理 程式碼：

/**
 * @author yaoxin
 * @date 2018/8/13下午5:04
 */
public class RedisLockTest {
 
    public static final String url = "jdbc:mysql://127.0.0.1:3306/ly?characterEncoding=UTF-8";
    public static final String name = "com.mysql.jdbc.Driver";
    public static final String user = "root";
    public static final String password = "";
 
    public static void main(String[] args) {
 
        Integer count = 50;
        while (count > 0) {
            count--;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Jedis jedis = new Jedis("127.0.0.1", 6379);
                    jedis.auth("1234");
                    String lock = lock(jedis);
                    if (lock != null) {
                        Statement statement = null;
                        Connection conn = null;
                        ResultSet resultSet = null;
                        try {
                            Class.forName(name);// 指定连接类型
                            conn = DriverManager.getConnection(url, user, password);// 获取连接
                            statement = conn.createStatement();// 准备执行语句
                            String querySql = "SELECT id,name,count FROM production WHERE id=2";
                            resultSet = statement.executeQuery(querySql);
                            int count = 0;
                            while (resultSet.next()) {
                                System.out.println(Thread.currentThread().getName() + "抢到了锁 id: " + resultSet.getString("id")
                                        + " name: " + resultSet.getString("name")
                                        + " count: " + resultSet.getString("count"));
                                count = Integer.valueOf(resultSet.getString("count"));
                            }
                            String updateSql = "UPDATE production SET count=" + (count - 1)
                                    + " WHERE id=2";
                            int rows = statement.executeUpdate(updateSql);
                            if (rows > 0) {
                                System.out.println("更新成功" + Thread.currentThread().getName() + "  库存剩余：" + (count - 1));
                                System.out.println(Thread.currentThread().getName() + " === > >开始解锁");
                                boolean unlock = unlock(jedis, lock);
                                if (unlock)
                                    System.out.println(Thread.currentThread().getName() + " === > >解锁成功");
                            } else {
                                System.out.println("更新失败" + Thread.currentThread().getName());
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        } finally {
                            try {
                                if (conn != null)
                                    conn.close();
                                if (statement != null)
                                    statement.close();
                                if (resultSet != null)
                                    resultSet.close();
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }, "线程" + count).start();
        }
    }
 
    public static String lock(Jedis jedis) {
        try {
            while (true) {
                String lockTime = Long.valueOf(jedis.time().get(0)) + 5 + "";
                if (jedis.setnx("lock", lockTime) == 1) {
                    jedis.expire("lock", 5);
                    return lockTime;
                }
                String lock = jedis.get("lock");
                if (!StringUtils.isEmpty(lock) && Long.valueOf(lock) < Long.valueOf(jedis.time().get(0))) {
                    String oldLockTime = jedis.getSet("lock", lockTime);
                    if (!StringUtils.isEmpty(oldLockTime) && oldLockTime.equals(lock)) {
                        return lockTime;
                    }
                }
                Thread.sleep(100);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static boolean unlock(Jedis jedis, String lockTag) {
        if (lockTag.equals(jedis.get("lock"))) {
            jedis.del("lock");
            return true;
        }
        return false;
    }
 
}

登入後複製

運行結果如下圖：

redis分散式鎖如何實現原理