So entwickeln Sie verteilte Sperrfunktionen mit Redis und Java

So verwenden Sie Redis und Java, um verteilte Sperrfunktionen zu entwickeln

1. Einführung
   Verteilte Sperren sind ein Mechanismus, um sich gegenseitig ausschließenden Zugriff auf gemeinsam genutzte Ressourcen in einem verteilten System zu ermöglichen. Wenn mehrere Knoten gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen, muss sichergestellt werden, dass nur ein Knoten zugreift und die anderen Knoten warten müssen. Redis ist eine häufig verwendete In-Memory-Datenbank mit hoher Leistung und hoher Zuverlässigkeit und eignet sich sehr gut für die Implementierung verteilter Sperren.
2. Der Setnx-Befehl von Redis
   Der Setnx-Befehl von Redis kann zum Festlegen des Werts eines Schlüssels verwendet werden, der Einstellvorgang wird jedoch nur ausgeführt, wenn der Schlüssel nicht vorhanden ist. Mit dieser Funktion können verteilte Sperrenerfassungsvorgänge implementiert werden. Versuchen Sie zunächst mit dem Befehl setnx, einen Schlüssel mit einer Ablaufzeit festzulegen. Wenn die Einstellung erfolgreich ist, bedeutet dies, dass die Sperre erfolgreich erworben wurde.
3. Java-Codebeispiel
   Das Folgende ist ein Beispielcode, der die Java-Sprache und Redis verwendet, um verteilte Sperren zu implementieren:

import redis.clients.jedis.Jedis;

public class DistributedLock {
    private static final String LOCK_KEY = "distributed_lock";
    private static final int LOCK_TIMEOUT = 3 * 1000; // 锁的超时时间，单位为毫秒
    
    private Jedis jedis;

    public DistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean lock() {
        long start = System.currentTimeMillis();
        try {
            while (true) {
                String result = jedis.set(LOCK_KEY, "locked", "NX", "PX", LOCK_TIMEOUT);
                if ("OK".equals(result)) {
                    return true;
                } else {
                    // 进行重试
                    Thread.sleep(100);
                }
                long end = System.currentTimeMillis();
                if (end - start > LOCK_TIMEOUT) {
                    // 超时退出
                    return false;
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }

    public void unlock() {
        jedis.del(LOCK_KEY);
    }
}

4. Beispielbeschreibung
   Im obigen Beispielcode wird die Jedis-Bibliothek zum Betrieb von Redis verwendet. Zunächst wird eine Konstante LOCK_KEY als Schlüssel der verteilten Sperre definiert. Dieser Schlüssel muss unter allen Knoten eindeutig bleiben. Darüber hinaus wird eine LOCK_TIMEOUT-Konstante festgelegt, um das Sperrzeitlimit darzustellen. LOCK_KEY作为分布式锁的键，这个键在所有节点中必须保持唯一。另外，设置了一个LOCK_TIMEOUT常量来表示锁的超时时间。

在lock方法中，首先获取当前时间作为开始时间，然后使用一个无限循环来尝试获取分布式锁。在循环中，使用Redis的set命令进行设置操作，设置键为LOCK_KEY，值为"locked"，并且设置了NX和PX选项，NX表示只有键不存在时才执行设置操作，PX表示设置键的过期时间为LOCK_TIMEOUT毫秒。

如果设置成功，则表示获取锁成功，方法返回true；否则继续进行重试，每次重试时会等待100毫秒。同时，还需要判断获取锁的时间是否超过了LOCK_TIMEOUT的值，如果超过则表示获取锁的等待时间已经过长，放弃获取锁，并返回false。

在unlock方法中，通过调用del

In der lock-Methode wird zunächst die aktuelle Zeit als Startzeit ermittelt und dann mithilfe einer Endlosschleife versucht, die verteilte Sperre zu erhalten. Verwenden Sie in der Schleife den Befehl set von Redis, um den Einstellungsvorgang durchzuführen. Der Set-Schlüssel ist LOCK_KEY, der Wert ist „locked“ und NX und PX Option, NX bedeutet, dass der Einstellungsvorgang nur ausgeführt wird, wenn der Schlüssel nicht vorhanden ist, PX bedeutet, dass die Ablaufzeit des Satzes Der Schlüssel ist LOCK_TIMEOUT code>Millisekunden. <li> <br>Wenn die Einstellung erfolgreich ist, bedeutet dies, dass die Sperre erfolgreich erworben wurde und die Methode <code>true zurückgibt. Andernfalls wird der erneute Versuch fortgesetzt und bei jedem erneuten Versuch 100 Millisekunden gewartet. Gleichzeitig muss auch festgestellt werden, ob die Zeit zum Erlangen der Sperre den Wert von LOCK_TIMEOUT überschreitet. Wenn dieser Wert überschritten wird, bedeutet dies, dass die Wartezeit zum Erlangen der Sperre zu lang war. Geben Sie den Erwerb der Sperre auf und geben Sie false zurück.

Löschen Sie in der Methode unlock den Schlüssel der verteilten Sperre, indem Sie den Befehl del aufrufen.

Aufrufbeispiel
6. Das Folgende ist ein Aufrufbeispiel mit dem Beispielcode:
   

import redis.clients.jedis.Jedis;

public class LockTest {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
        DistributedLock lock = new DistributedLock(jedis);
        try {
            if (lock.lock()) {
                // 获取到分布式锁后执行需要保护的代码
                System.out.println("获取到分布式锁");
                // ... 执行需要保护的代码
            } else {
                System.out.println("获取分布式锁失败");
            }
        } finally {
            lock.unlock();
        }
    }
}

Im Aufrufbeispiel wird zuerst ein Jedis-Verbindungsobjekt erstellt, dann wird ein DistributedLock-Objekt erstellt und das Jedis-Verbindungsobjekt wird als übergeben ein Parameter. Versuchen Sie im Try-Finally-Block zunächst, die verteilte Sperre zu erhalten. Geben Sie bei Erfolg „erhaltene verteilte Sperre“ aus, führen Sie den zu schützenden Code aus und geben Sie dann die verteilte Sperre im Final-Block frei. 🎜🎜🎜Zusammenfassung🎜Durch die Verwendung von Redis und der Java-Entwicklung können wir die verteilte Sperrfunktion problemlos implementieren. Der Sperrerfassungsvorgang kann mit dem Redis-Befehl setnx implementiert werden, und der Java-Code kann den Redis-Befehl problemlos aufrufen und in eine verteilte Sperrklasse einkapseln. In tatsächlichen Anwendungen kann das Timeout der verteilten Sperre nach Bedarf angepasst werden, um sicherzustellen, dass die Wartezeit für den Erwerb der Sperre nicht zu lang wird, wodurch die Leistung und Parallelität des Systems verbessert werden. 🎜🎜

Das obige ist der detaillierte Inhalt vonSo entwickeln Sie verteilte Sperrfunktionen mit Redis und Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!