StampedLock en optimistische leesbewerkingen
Pas de optimistische leesmodus van StampedLock toe voor werklasten met hoge doorvoer die voornamelijk uit leesbewerkingen bestaan.
StampedLock en optimistische leesbewerkingen is een gratis Java Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.
Wat is StampedLock?
StampedLock werd geïntroduceerd in Java 8 en breidt de concepten van ReadWriteLock uit met een extra modus voor optimistisch lezen. Bewerkingen geven een lange stempel terug die wordt gebruikt om de vergrendeling vrij te geven of het optimistische lezen te valideren.
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 voor optimistisch lezen
Bij optimistisch lezen wordt geen vergrendeling verkregen — er wordt alleen een stempel opgehaald. Valideer de stempel na het lezen. Als de validatie mislukt (een schrijver heeft tussendoor geschreven), val je terug op een echte leesvergrendeling:
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 localYVolledig Point2D-voorbeeld
Klassiek StampedLock-voorbeeld — een tweedimensionaal punt met optimistisch lezen:
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);
}
}Vergrendelingsconversie
StampedLock ondersteunt het converteren tussen vergrendelingsmodi:
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);
}Wanneer optimistisch lezen het meest helpt
Optimistisch lezen is vooral effectief wanneer:
- Er veel vaker wordt gelezen dan geschreven
- De momentopname van de gegevens in enkele lokale variabelen past (zonder objecttoewijzing)
- Er weinig concurrentie bij het schrijven is (validatie mislukt zelden)
Als er vaak wordt geschreven, vallen optimistische lezingen steeds terug op volledige leesvergrendelingen — zonder voordeel.
StampedLock versus ReadWriteLock
Belangrijkste verschillen:
- StampedLock: voegt optimistisch lezen toe; is NIET herintredend; biedt geen ondersteuning voor Condition
- ReentrantReadWriteLock: is herintredend; ondersteunt Conditions; heeft geen optimistische modus
StampedLock is sneller bij weinig concurrentie voor schrijfbewerkingen. ReentrantReadWriteLock is veiliger en biedt meer mogelijkheden.
StampedLock is NIET herintredend
In tegenstelling tot ReentrantLock is StampedLock NIET herintredend. Een thread die een modus probeert te verkrijgen die hij al vasthoudt, veroorzaakt een deadlock:
StampedLock sl4 = new StampedLock();
long s1 = sl4.readLock();
// DO NOT: sl4.readLock() again — deadlocks with non-reentrant!tryWriteLock en tryReadLock
Niet-blokkerende pogingen om de vergrendeling te verkrijgen geven 0 terug als ze mislukken:
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");
}Gebruiken als ReadWriteLock
StampedLock kan voor compatibiliteit een weergave als standaard ReadWriteLock teruggeven:
StampedLock sl6 = new StampedLock();
Lock readLock = sl6.asReadLock();
Lock writeLock = sl6.asWriteLock();
ReadWriteLock rwView = sl6.asReadWriteLock();
// These provide standard Lock interface without optimistic modeIntuïtie bij prestatiebenchmarks
Benchmarkresultaten laten doorgaans het volgende zien:
- Situatie met zeer veel lezingen (99% lezingen): StampedLock > ReadWriteLock > synchronized
- Gemengde werklast (70% lezingen): ReadWriteLock ≈ StampedLock
- Situatie met veel schrijfbewerkingen: synchronized of ReentrantLock wint vaak (minder overhead)
Meet de prestaties altijd met realistische werklasten voordat je optimaliseert.
Ongeldigheid van de stempel na ontgrendelen
Na het vrijgeven van een vergrendeling met een stempel wordt die stempel ongeldig. Het gebruiken van een oude stempel na het ontgrendelen leidt tot ongedefinieerd gedrag — haal voor elke verkrijging van een vergrendeling altijd een nieuwe stempel op.
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 stateKorte controle
Een optimistische lezing met tryOptimisticRead() en een daaropvolgende validate(stamp) geeft false terug. Wat moet de code vervolgens doen?
Samenvatting: StampedLock
Belangrijkste punten:
- Drie modi: optimistisch lezen (geen vergrendeling), leesvergrendeling en schrijfvergrendeling
- tryOptimisticRead() + validate() — poging tot lezen zonder kosten
- Bij een mislukte validatie → terugvallen op readLock()
- NIET herintredend — risico op deadlock als dezelfde thread de vergrendeling opnieuw verkrijgt
- Geen ondersteuning voor Condition — gebruik ReentrantReadWriteLock wanneer dat nodig is
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “StampedLock en optimistische leesbewerkingen” gratis?
Ja — de volledige tekst van “StampedLock en optimistische leesbewerkingen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.
Wat leer ik in “StampedLock en optimistische leesbewerkingen”?
Pas de optimistische leesmodus van StampedLock toe voor werklasten met hoge doorvoer die voornamelijk uit leesbewerkingen bestaan. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “StampedLock en optimistische leesbewerkingen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- ReentrantLock versus synchronized
- ReadWriteLock voor readers-writerscenario's
- Atomic-variabelen: lockvrije updates
- StampedLock en optimistische leesbewerkingen