Java Academy · Lektion

StampedLock und optimistische Lesezugriffe

Wenden Sie den optimistischen Lesemodus von StampedLock bei leseintensiven Workloads mit hohem Durchsatz an.

Lektion 4 von 413 Schritte

StampedLock und optimistische Lesezugriffe ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist StampedLock?

StampedLock wurde in Java 8 eingeführt und erweitert die Konzepte von ReadWriteLock um einen zusätzlichen Modus für optimistisches Lesen. Die Operationen geben einen langen Stempel zurück, der zum Freigeben der Sperre oder zum Validieren des optimistischen Lesezugriffs verwendet wird.

import java.util.concurrent.locks.*;

StampedLock sl = new StampedLock();

// Exclusive write:
long stamp = sl.writeLock();
try {
    // write data
} finally {
    sl.unlockWrite(stamp);
}

// Shared read:
stamp = sl.readLock();
try {
    // read data
} finally {
    sl.unlockRead(stamp);
}

Modus für optimistisches Lesen

Beim optimistischen Lesen wird keine Sperre erworben — stattdessen wird lediglich ein Stempel abgerufen. Validieren Sie den Stempel nach dem Lesen. Wenn die Validierung fehlschlägt (ein Schreiber hat eingegriffen), wechseln Sie zu einer echten Lesesperre:

StampedLock sl2 = new StampedLock();
double x = 0, y = 0;

// Try optimistic read first:
long stamp = sl2.tryOptimisticRead();
double localX = x, localY = y; // read values

if (!sl2.validate(stamp)) {
    // A write occurred — fall back to read lock
    stamp = sl2.readLock();
    try {
        localX = x;
        localY = y;
    } finally {
        sl2.unlockRead(stamp);
    }
}
// use localX and localY

Vollständiges Point2D-Beispiel

Klassisches StampedLock-Beispiel — ein 2D-Punkt mit optimistischen Lesezugriffen:

class Point {
    private double x, y;
    private final StampedLock lock = new StampedLock();
    
    void move(double dx, double dy) {
        long stamp = lock.writeLock();
        try { x += dx; y += dy; }
        finally { lock.unlockWrite(stamp); }
    }
    
    double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();
        double cx = x, cy = y;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try { cx = x; cy = y; }
            finally { lock.unlockRead(stamp); }
        }
        return Math.sqrt(cx * cx + cy * cy);
    }
}

Konvertierung von Sperren

StampedLock unterstützt die Konvertierung zwischen Sperrmodi:

StampedLock sl3 = new StampedLock();

// Read → Write upgrade attempt:
long readStamp = sl3.readLock();
long writeStamp = sl3.tryConvertToWriteLock(readStamp);
if (writeStamp != 0) {
    // Successfully upgraded!
    // ... write ...
    sl3.unlockWrite(writeStamp);
} else {
    // Upgrade failed — release read and reacquire write
    sl3.unlockRead(readStamp);
    writeStamp = sl3.writeLock();
    // ... write ...
    sl3.unlockWrite(writeStamp);
}

Wann optimistische Lesezugriffe besonders hilfreich sind

Optimistische Lesezugriffe spielen ihre Stärken aus, wenn:

Lesezugriffe sehr viel häufiger als Schreibzugriffe sind
der Daten-Snapshot in wenige lokale Variablen passt (keine Objekterzeugung)
die Konkurrenz bei Schreibzugriffen gering ist (die Validierung schlägt nur selten fehl)

Wenn Schreibzugriffe häufig sind, greifen optimistische Lesezugriffe wiederholt auf vollständige Lesesperren zurück — dadurch entsteht kein Vorteil.

StampedLock vs ReadWriteLock

Wichtige Unterschiede:

StampedLock: bietet optimistische Lesezugriffe; NICHT wiedereintrittsfähig; keine Unterstützung für Condition
ReentrantReadWriteLock: wiedereintrittsfähig; unterstützt Conditions; kein optimistischer Modus

StampedLock ist bei geringer Konkurrenz durch Schreibzugriffe schneller. ReentrantReadWriteLock ist sicherer und bietet mehr Funktionen.

StampedLock ist NICHT wiedereintrittsfähig

Im Gegensatz zu ReentrantLock ist StampedLock NICHT wiedereintrittsfähig. Ein Thread, der versucht, einen Modus zu erwerben, den er bereits hält, verursacht einen Deadlock:

StampedLock sl4 = new StampedLock();
long s1 = sl4.readLock();
// DO NOT: sl4.readLock() again — deadlocks with non-reentrant!

tryWriteLock und tryReadLock

Nicht blockierende Erwerbsversuche geben bei einem Fehlschlag 0 zurück:

StampedLock sl5 = new StampedLock();

long stamp = sl5.tryWriteLock();
if (stamp != 0) {
    try {
        System.out.println("Got write lock");
    } finally {
        sl5.unlockWrite(stamp);
    }
} else {
    System.out.println("Write lock unavailable");
}

Verwendung als ReadWriteLock

StampedLock kann zur Kompatibilität eine Ansicht als standardmäßiges ReadWriteLock zurückgeben:

StampedLock sl6 = new StampedLock();
Lock readLock  = sl6.asReadLock();
Lock writeLock = sl6.asWriteLock();
ReadWriteLock rwView = sl6.asReadWriteLock();
// These provide standard Lock interface without optimistic mode

Intuition zur Leistungsbewertung

Benchmark-Ergebnisse zeigen typischerweise:

Sehr leseintensiv (99 % Lesezugriffe): StampedLock > ReadWriteLock > synchronized
Gemischter Workload (70 % Lesezugriffe): ReadWriteLock ≈ StampedLock
Schreibintensiv: synchronized oder ReentrantLock gewinnt häufig (weniger Overhead)

Führen Sie vor der Optimierung immer ein Profiling mit realistischen Workloads durch.

Ungültigkeit des Stempels nach dem Entsperren

Nach dem Freigeben einer Sperre mit einem Stempel wird dieser Stempel ungültig. Die Verwendung eines alten Stempels nach dem Entsperren führt zu undefiniertem Verhalten — erfassen Sie für jeden Erwerb einer Sperre immer einen neuen Stempel.

StampedLock sl7 = new StampedLock();
long stamp = sl7.writeLock();
sl7.unlockWrite(stamp);
// stamp is now invalid — don't use it:
// sl7.unlockWrite(stamp); // throws IllegalMonitorStateException or corrupts state

Kurzer Test

Ein optimistischer Lesezugriff mit tryOptimisticRead() und einem anschließenden validate(stamp) gibt false zurück. Was sollte der Code als Nächstes tun?

Beantworte es in der interaktiven Lektion

Zusammenfassung: StampedLock

Wichtige Erkenntnisse:

Drei Modi: optimistischer Lesezugriff (keine Sperre), Lesesperre, Schreibsperre
tryOptimisticRead() + validate() — Leseversuch ohne Kosten
Bei fehlgeschlagener Validierung → auf readLock() zurückgreifen
NICHT wiedereintrittsfähig — Deadlock-Risiko bei erneutem Erwerb durch denselben Thread
Keine Unterstützung für Condition — verwenden Sie bei Bedarf ReentrantReadWriteLock

Kostenlos starten

Lerne Java mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 104
Lektionen: 374

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „StampedLock und optimistische Lesezugriffe“ kostenlos?

Ja — der vollständige Text von „StampedLock und optimistische Lesezugriffe“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „StampedLock und optimistische Lesezugriffe“?

Wenden Sie den optimistischen Lesemodus von StampedLock bei leseintensiven Workloads mit hohem Durchsatz an. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „StampedLock und optimistische Lesezugriffe“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

ReentrantLock vs. synchronized
ReadWriteLock für Leser-Schreiber-Szenarien
Atomare Variablen: Aktualisierungen ohne Locks
StampedLock und optimistische Lesezugriffe

← Zurück zu Java Academy