Verwenden Sie Redis, um verteilte Sperren zu implementieren und so die Datensicherheit zu gewährleisten

Mit der kontinuierlichen Weiterentwicklung der Internettechnologie werden verteilte Systeme immer häufiger in der Entwicklung eingesetzt, insbesondere in Szenarien mit hoher Parallelität und Datenverarbeitung in großem Maßstab. Verteilte Systeme können die Skalierbarkeit des Systems verbessern und die Effizienz verbessern des Systems. Da die Daten jedoch in einem verteilten System auf mehrere Maschinen verteilt sind, kann es leicht zu Problemen wie Dateninkonsistenzen oder wiederholten Vorgängen kommen. Um diese Probleme zu lösen, müssen wir häufig verteilte Sperren verwenden.

Verteilte Sperre ist ein Sperrmechanismus, der zur Aufrechterhaltung der Datenkonsistenz in verteilten Systemen vorgeschlagen wird. Er wird hauptsächlich verwendet, um Probleme wie Datenkonkurrenz und Dateninkonsistenz in verteilten Systemen zu vermeiden. Im herkömmlichen eigenständigen Sperrmechanismus wird er im Allgemeinen mithilfe von synchronisiertem oder ReentrantLock implementiert. In einem verteilten System muss die Sperrimplementierungslösung jedoch Probleme wie Netzwerkverzögerung und Parallelität berücksichtigen, was den Einsatz einer speziellen verteilten Sperrtechnologie erfordert.

Redis wird als leistungsstarke Schlüsselwertspeicherdatenbank häufig zur Implementierung des Sperrmechanismus verteilter Systeme verwendet. Redis bietet eine Vielzahl verteilter Methoden zur Implementierung von Sperren, z. B. Sperren basierend auf SETNX-Befehlen, Sperren basierend auf dem Redlock-Algorithmus und Sperren basierend auf Lua-Skripten. Als Nächstes stellen wir Ihnen die verteilte Sperrimplementierungslösung von Redis basierend auf dem SETNX-Befehl vor.

Redis Distributed Lock-Implementierungsprinzip

Der SETNX-Befehl von Redis wird verwendet, um den Wert eines bestimmten Schlüssels in Redis festzulegen. Wenn der Schlüssel nicht vorhanden ist, ist die Einstellung erfolgreich und 1 wird zurückgegeben wird zurückgegeben. Mit dieser Funktion können wir verteilte Sperren implementieren.

Wenn wir bestimmte Daten sperren müssen, verwenden wir den SETNX-Befehl, um zu versuchen, den Wert eines bestimmten Schlüssels auf 1 zu setzen. Wenn die Einstellung erfolgreich ist, bedeutet dies, dass derzeit kein anderer Client die Sperre hält und die Sperre erfolgreich ist. Wenn die Einstellung fehlschlägt, bedeutet dies, dass derzeit andere Clients die Sperre halten und die Sperre fehlschlägt. Beim Entsperren müssen wir nur den dem Schloss entsprechenden Schlüssel löschen.

Schritte zur Implementierung verteilter Redis-Sperren

Im Folgenden stellen wir vor, wie verteilte Sperren über Redis implementiert werden, um die Datensicherheit zu gewährleisten. Die folgenden Schritte sind nur Beispiele und müssen entsprechend den spezifischen Bedingungen in tatsächlichen Anwendungen angepasst werden.

1. Stellen Sie den Redis-Client vor

In Java können wir entweder Jedis oder Lettuce, die beiden Redis-Client-Toolkits, verwenden, um Redis-bezogene Vorgänge auszuführen. Sie können der pom.xml-Datei die folgenden Abhängigkeiten hinzufügen:

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>3.0.1</version>
</dependency>

2. Erstellen Sie eine Redis-Verbindung

Bevor Sie Redis verwenden, müssen Sie eine Verbindung mit dem Redis-Dienst erstellen. Sie können das von Jedis bereitgestellte JedisPool-Objekt verwenden. Der Parameter maxTotal gibt die maximale Anzahl von Verbindungen im Verbindungspool an, der Parameter maxIdle gibt die maximale Anzahl inaktiver Verbindungen im Verbindungspool an und das Timeout ist auf 5000 Millisekunden festgelegt.

JedisPool jedisPool = new JedisPool(new GenericObjectPoolConfig(),
        "localhost",
        6379, 
        5000, 
        "password");

3. Sperrvorgang

Wir implementieren die Sperr- und Entsperrlogik, indem wir eine LockUtil-Klasse kapseln. Bei der Sperroperation versuchen wir, den Wert eines bestimmten Schlüssels mit dem SetNx-Befehl auf 1 zu setzen. Wenn die Einstellung erfolgreich ist, wird true zurückgegeben. Wenn die Einstellung fehlschlägt, bedeutet dies, dass die Sperre von anderen Threads belegt wurde. und false wird zurückgegeben. Es ist zu beachten, dass nach erfolgreicher Sperrung aus bestimmten Gründen ein Timeout festgelegt werden muss, um einen Deadlock zu vermeiden.

public class LockUtil {

    private static final String LOCK_KEY_PREFIX = "lock:";

    public static boolean lock(String key, int timeout) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String lockKey = LOCK_KEY_PREFIX + key;
            long start = System.currentTimeMillis();
            while (true) {
                // 使用SETNX命令来设置key的值为1
                long result = jedis.setnx(lockKey, "1");
                // 设置成功
                if (result == 1) {
                    jedis.expire(lockKey, timeout);
                    return true;
                }
                // 设置失败
                else {
                    // 检查是否超时
                    long end = System.currentTimeMillis();
                    if (end - start > timeout) {
                        return false;
                    }
                }
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            return false;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

4. Entsperrvorgang

Beim Entsperrvorgang verwenden wir den Befehl del, um den Schlüssel zu löschen und die Ressourcen freizugeben.

public class LockUtil {
    
    public static boolean unlock(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String lockKey = LOCK_KEY_PREFIX + key;
            jedis.del(lockKey);
            return true;
        } catch (Exception e) {
            return false;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

5. Testen Sie abschließend mit einem einfachen Test, ob unsere verteilte Sperre ordnungsgemäß funktioniert, wie unten gezeigt:

@Test
public void testLock() throws InterruptedException {
    ExecutorService executorService = Executors.newFixedThreadPool(10);
    for (int i = 0; i < 10; i++) {
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                boolean lockResult = LockUtil.lock("test", 5000);
                if (lockResult) {
                    System.out.println(Thread.currentThread().getName() + " get lock");
                    try {
                        // 处理业务
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        LockUtil.unlock("test");
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + " fail to get lock");
                }
            }
        });
    }
    sleep(100000);
}

Der obige Code erstellt 10 Threads. Jeder Thread versucht, den gleichen Sperrschlüssel zu erhalten. Führen Sie einige Geschäftsvorgänge aus und geben Sie die Sperrressource nach 5 Sekunden frei. Wenn die verteilte Sperre erfolgreich implementiert wird, kann jeder Thread die Sperre erfolgreich erwerben und die Geschäftsverarbeitung abschließen.

Anhand des obigen Beispiels können wir sehen, dass mit dem SETNX-Befehl von Redis ein einfacher und effizienter verteilter Sperrmechanismus implementiert werden kann, um die Datensicherheit im verteilten System effektiv zu gewährleisten. Im eigentlichen Bewerbungsprozess müssen wir den Sperrimplementierungsplan basierend auf tatsächlichen Geschäftsszenarien und -anforderungen anpassen und optimieren.

Das obige ist der detaillierte Inhalt vonVerwenden Sie Redis, um verteilte Sperren zu implementieren und so die Datensicherheit zu gewährleisten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!