Einführung in das Implementierungsprinzip von ReentrantLock (Codebeispiel)

Dieser Artikel bietet Ihnen eine Einführung in die Implementierungsprinzipien von ReentrantLock (Codebeispiele). Ich hoffe, dass er für Freunde hilfreich ist.

In der gleichzeitigen Programmierung sind neben dem synchronisierten Schlüsselwort auch ReentrantLock und ReentrantReadWriteLock in java.util.concurrent.locks im Java-Parallelitätspaket häufig verwendete Sperrimplementierungen. In diesem Artikel wird das Prinzip der Wiedereintrittssperre anhand des Quellcodes analysiert.

Lassen Sie uns zunächst über wiedereintrittsfähige Sperren sprechen: Nachdem ein Thread die Sperre erhalten hat, kann er die Sperre mehrmals erhalten, ohne sich selbst zu blockieren.

ReentrantLock wird basierend auf der abstrakten Klasse AbstractQueuedSynchronizer (im Folgenden als AQS bezeichnet) implementiert.

Sehen Sie sich den Quellcode an:

Zunächst ist aus dem Konstruktor ersichtlich, dass ReentrantLock über zwei Mechanismen verfügt: Fair Lock und Unfair Lock.

//默认非公平锁
public ReentrantLock() {
        sync = new NonfairSync();
    }

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

Erklären Sie zunächst kurz den Unterschied zwischen fairen und unfairen Sperren und analysieren Sie dann die unterschiedlichen Implementierungsmethoden der beiden.

Gerechte Sperre: Mehrere Threads werden nach dem Prinzip „Wer zuerst kommt, mahlt zuerst“ vergeben. Ähnlich wie bei der Warteschlange werden später kommende Threads am Ende der Warteschlange platziert.

Unfaire Sperre: Wettbewerb um Sperren. Wenn es erfasst wird, wird es ausgeführt. Wenn es nicht erfasst wird, wird es blockiert. Warten Sie, bis der Thread, der die Sperre erhalten hat, freigegeben wird, bevor Sie am Wettbewerb teilnehmen.

Daher kommen meist unfaire Sperren zum Einsatz. Seine Effizienz ist höher als bei Fair Lock.

Sperre erhalten

Faire Sperre

final void lock() {
            acquire(1);
        }

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

Erster Schritt tryAcquire(arg) Versuchen Sie hinzuzufügen Lock, implementiert von FairSync, der spezifische Code lautet wie folgt:

protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

• Holen Sie sich den aktuellen Thread

• Erhalten Sie den Status in AQS. Wenn der Status 0 ist, bedeutet dies, dass zu diesem Zeitpunkt kein Thread die Sperre erhalten hat. ​

• Bei der if-Beurteilung muss zunächst beurteilt werden, ob die AQS-Knotenwarteschlange leer ist. Wenn es nicht leer ist, müssen Sie sich anstellen. Die Sperre ist zu diesem Zeitpunkt noch nicht erworben.

• Versuchen Sie, den CAS-Algorithmus zu verwenden, um den Status auf 1 zu aktualisieren. Das Update ist erfolgreich, die Sperre wird erworben und der Thread wird zu diesem Zeitpunkt auf den exklusiven Thread exclusiveOwnerThread gesetzt. Gibt true zurück.

• Wenn der Status nicht 0 ist, bedeutet dies, dass ein Thread die Sperre bereits erhalten hat. Daher muss festgestellt werden, ob der Thread, der die Sperre erhalten hat (exklusiver Thread), der aktuelle Thread ist.

• Wenn ja, bedeutet das einen Wiedereintritt. Zustand um 1 erhöhen. Gibt true zurück.

• Im letzten Schritt wird die Sperre nicht erhalten. Return false;

Fahren Sie mit den oben genannten Schritten fort, führen Sie zuerst addWaiter(Node.EXCLUSIVE) aus und schreiben Sie den aktuellen Thread in die Warteschlange

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

• Einen neuen Knotenknoten kapseln

• Bestimmen Sie, ob das Ende der verknüpften Liste leer ist. Wenn nicht, schreibe den neuen Knoten node' bis zum Ende

• 'Wenn das Ende der verknüpften Liste leer ist, verwende enq(node), um bis zum Ende zu schreiben.

Nach dem Schreiben in die Warteschlange unterbricht die Methode acquireQueued() den aktuellen Thread.

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

• Wenn in der Schleife der vorherige Knoten der Hauptknoten ist, versuchen Sie erneut, die Sperre zu erhalten. Bei Erfolg wird die Schleife beendet und false zurückgegeben.

• ist nicht der Hauptknoten. Basierend auf dem Wartestatus des vorherigen Knotens wird beurteilt, ob der aktuelle Thread angehalten werden muss. waitStatus wird zum Aufzeichnen des Knotenstatus verwendet, z. B. Knotenstornierung, Knotenwartezeit usw.

• Wenn Sie feststellen, dass er angehalten werden muss, verwenden Sie die Methode parkAndCheckInterrupt(), um den Thread anzuhalten. Verwenden Sie insbesondere LockSupport.park(this), um den Thread anzuhalten.

• Wenn die Sperrenerfassung im ersten Schritt hier erfolgreich ist, können Sie den Sperrenerfassungsvorgang für diesen Knoten abbrechen.

Unfaire Sperre

Unfaire Sperre weist Unterschiede in der Sperrerwerbsstrategie auf.

final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
 protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }

• Die unfaire Sperre versucht zunächst direkt, den CAS-Algorithmus zu verwenden, um den Status zu aktualisieren und die Sperre zu erhalten

• Nachdem das Update fehlgeschlagen ist, wird gerade versucht, die Sperre zu erhalten

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

Verglichen mit der fairen Sperre , versucht die unfaire Sperre, die Sperre zu erlangen. Es ist nicht erforderlich, festzustellen, ob sich andere Threads in der Warteschlange befinden.

Sperre aufheben

Die Schritte zum Aufheben der Sperre sind für faire und unfaire Sperren gleich

public void unlock() {
        sync.release(1);
    }
public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
//更新state
protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

Es ist erwähnenswert, dass der Status in der tryRelease()-Methode auf 0 aktualisiert werden muss, bevor die Sperre als vollständig freigegeben betrachtet wird, da es sich um eine Wiedereintrittssperre handelt. Nach dem Loslassen wird der angehaltene Thread aktiviert.

Das obige ist der detaillierte Inhalt vonEinführung in das Implementierungsprinzip von ReentrantLock (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!