Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

StampedLock: optimistické čtení, zápis a opakování pod čtecím zámkem

Zjistěte, kdy lze použít optimisticky načtená data a jak čtení zopakovat pod sdíleným zámkem, který uvolníte správnou značkou.

Verze: Java SE 21

Syntaxe

java.util.concurrent.locks.StampedLock — Java SE 21
public long tryOptimisticRead()
public boolean validate(long stamp)
public long writeLock()
public void unlockWrite(long stamp)
public long readLock()
public void unlockRead(long stamp)

V Java SE 21 podporuje java.util.concurrent.locks.StampedLock výhradní zápis, sdílené čtení a optimistické čtení. tryOptimisticRead() nečeká ani nezískává zámek: vrací značku typu long nebo 0L, pokud je zámek právě držen v režimu zápisu. S optimistickou značkou se žádný zámek neuvolňuje.

Při nenulové značce zkopírujte potřebná pole do lokálních proměnných a poté zavolejte validate(long) na stejném zámku. U čerstvé optimistické značky znamená true, že od jejího vydání nebyl získán zámek pro zápis. Pozdějšímu zápisu to nebrání. validate(0L) vždy vrací false. Před úspěšným ověřením mohou být kopie nekonzistentní: nepoužívejte je ve voláních ani operacích, které předpokládají konzistenci. Pokud ověření vrátí false, zahoďte všechny kopie.

writeLock() získá výhradní zámek a v případě potřeby čeká. Už samotné získání zneplatní předchozí optimistické značky, i když se data nezmění, a to i po uvolnění zámku. Chráněná data měňte pod zámkem pro zápis a jeho značku předejte v finally metodě unlockWrite(long).

Při 0L nebo neúspěšném ověření použijte readLock() k získání sdíleného zámku; v případě potřeby metoda čeká. Načtěte všechna potřebná pole znovu a v finally zavolejte unlockRead(long) se značkou vrácenou metodou readLock(), nikoli s optimistickou značkou. Pokud značka neodpovídá stavu zámku, metody pro uvolnění vyhodí IllegalMonitorStateException. Zámek není reentrantní: nepokoušejte se ho získat znovu, dokud ho držíte. Značky nejsou bezpečnostními přihlašovacími údaji.

Příklady

import java.util.concurrent.locks.StampedLock;

public class StampedLockDemo {
    private final StampedLock lock = new StampedLock();
    private int value = 10;

    private void write(int newValue) {
        long writeStamp = lock.writeLock();
        try {
            value = newValue;
        } finally {
            lock.unlockWrite(writeStamp);
        }
    }

    private void demo() {
        long firstStamp = lock.tryOptimisticRead();
        int firstCopy = value;
        boolean firstValid = lock.validate(firstStamp);
        System.out.println("first valid: " + firstValid);
        if (firstValid) {
            System.out.println("first value: " + firstCopy);
        }

        long secondStamp = lock.tryOptimisticRead();
        int secondCopy = value;
        write(20);
        boolean secondValid = lock.validate(secondStamp);
        System.out.println("second valid: " + secondValid);
        if (!secondValid) {
            long readStamp = lock.readLock();
            try {
                secondCopy = value;
            } finally {
                lock.unlockRead(readStamp);
            }
        }
        System.out.println("second value: " + secondCopy);
    }

    public static void main(String[] args) {
        new StampedLockDemo().demo();
    }
}

Výsledek

first valid: true
first value: 10
second valid: false
second value: 20

Příklad běží v jediném vlákně. První čtení projde ověřením a vrátí `10`. Při druhém čtení se `20` záměrně zapíše mezi zkopírováním pole a ověřením. Zastaralou kopii nahradí `20` načtené pod zámkem, který se uvolní pomocí `readStamp`.

Související lekce

  • Java · Lekce 29 · Pokročilá · Verze: 2

Zdroje