Eine verteilte Sperre ist eine Methode zur Steuerung des synchronisierten Zugriffs auf gemeinsam genutzte Ressourcen zwischen verteilten Systemen.

Im Folgenden wird vorgestellt, wie Zookeeper verteilte Sperren implementiert, und es werden zwei Arten von verteilten Sperren erklärt: exklusive Sperren und gemeinsame Sperren.

Exklusive Sperre

Exklusive Sperren, auch bekannt als Schreibsperren oder exklusive Sperren, wenn Transaktion T1 eine exklusive Sperre auf Datenobjekt O1 setzt, darf während der gesamten Sperrphase nur Transaktion T1 O1 lesen und aktualisieren; keine andere Transaktion kann lesen oder schreiben.

Die Sperre definieren:

/exclusive_lock/lock

Implementierung:

Unter Ausnutzung der Einzigartigkeit der Sibling-Knoten von Zookeeper versuchen alle Clients, wenn eine exklusive Sperre erworben werden muss, die create()-Schnittstelle aufzurufen, um/exclusive_lockeinen temporären Kindknoten unter dem Knoten/exclusive_lock/lock zu erstellen, letztendlich kann nur ein Client erfolgreich erstellen, und dieser Client erhält die verteilte Sperre. Gleichzeitig können alle Clients, die die Sperre nicht erworben haben, auf dem Knoten/exclusive_lockein Watcher-Listener-Ereignis für Änderungen an Kindknoten registrieren, um erneut um die Sperre zu konkurrieren.

Gemeinsame Sperre

Gemeinsame Sperren, auch bekannt als Lesesperren. Wenn Transaktion T1 eine gemeinsame Sperre auf Datenobjekt O1 setzt, kann die aktuelle Transaktion nur Leseoperationen auf O1 ausführen, und andere Transaktionen können diesem Datenobjekt nur gemeinsame Sperren hinzufügen, bis alle gemeinsamen Sperren auf dem Datenobjekt freigegeben sind.

Die Sperre definieren:

/shared_lock/[hostname]-请求类型W/R-序号

Implementierung:

1. Der Client ruft die Methode create auf, um einen temporären sequenziellen Knoten zu erstellen, ähnlich der Methode zur Sperrdefinition.

2. Der Client ruft die Schnittstelle getChildren auf, um eine Liste aller erstellten untergeordneten Knoten zu erhalten.

3. Bestimmen Sie, ob die Sperre erhalten wurde. Bei Leseanforderungen, wenn alle untergeordneten Knoten, die kleiner als sie selbst sind, Leseanforderungen sind oder es keine untergeordneten Knoten mit einer kleineren Sequenznummer als sie selbst gibt, zeigt dies an, dass die gemeinsame Sperre erfolgreich erworben wurde und die Leselogik mit der Ausführung beginnt. Bei Schreibanforderungen, wenn er nicht der untergeordnete Knoten mit der kleinsten Sequenznummer ist, tritt er in einen Wartezustand ein.

4. Wenn die gemeinsame Sperre nicht erworben wurde, registrieren Leseanforderungen einen Watcher auf dem letzten Schreibanforderungsknoten mit einer kleineren Sequenznummer als sie selbst, und Schreibanforderungen registrieren einen Watcher auf dem letzten Knoten mit einer kleineren Sequenznummer als sie selbst.

In der tatsächlichen Entwicklung können wir die im Curator-Toolkit gekapselten APIs verwenden, um uns bei der Implementierung verteilter Sperren zu helfen.

<dependency> <groupId>org.apache.curator</groupId> <artifactId>curator-recipes</artifactId> <version>x.x.x</version> </dependency>

Mehrere Sperrschemata von Curator:

  • 1、InterProcessMutex: Verteilte reentrante exklusive Sperre
  • 2、InterProcessSemaphoreMutex: Verteilte exklusive Sperre
  • 3、InterProcessReadWriteLock: Verteilte Lese-/Schreibsperre

Das folgende Beispiel simuliert 50 Threads, die mit der reentranten exklusiven Sperre InterProcessMutex gleichzeitig um die Sperre konkurrieren:

Beispiel

public class InterprocessLock {
    public static void main(String[] args)  {
        CuratorFramework zkClient = getZkClient();
        String lockPath = "/lock";
        InterProcessMutex lock = new InterProcessMutex(zkClient, lockPath);
        //Simuliere 50 Threads, die um die Sperre konkurrieren
        for (int i = 0; i < 50; i++) {
            new Thread(new TestThread(i, lock)).start();
        }
    }


    static class TestThread implements Runnable {
        private Integer threadFlag;
        private InterProcessMutex lock;

        public TestThread(Integer threadFlag, InterProcessMutex lock) {
            this.threadFlag = threadFlag;
            this.lock = lock;
        }

        @Override
        public void run() {
            try {
                lock.acquire();
                System.out.println(Der+threadFlag+Thread hat die Sperre erworben);
                //Warte 1 Sekunde, dann gib die Sperre frei
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    lock.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static CuratorFramework getZkClient() {
        String zkServerAddress = "192.168.3.39:2181";
        ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(1000, 3, 5000);
        CuratorFramework zkClient = CuratorFrameworkFactory.builder()
                .connectString(zkServerAddress)
                .sessionTimeoutMs(5000)
                .connectionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .build();
        zkClient.start();
        return zkClient;
    }
}

Die Konsole gibt jede Sekunde einen Datensatz aus:

Quellcode-Download für dieses Kapitel

Herunterladen