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

CKTIS / Java

Metody ReentrantLock: získání zámku, opakovaný vstup a podmínky

Rozlišujte blokující `lock()` a dvě přetížení `tryLock()`, ke každému úspěšnému získání přiřaďte `unlock()` a používejte samostatné podmínky jednoho zámku.

Verze: Java SE 21

Syntaxe

// Java SE 21 — instance methods of java.util.concurrent.locks.ReentrantLock
public void lock()
public void unlock()
public boolean tryLock()
public boolean tryLock(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException
public java.util.concurrent.locks.Condition newCondition()
public int getHoldCount()

V Java SE 21 je java.util.concurrent.locks.ReentrantLock reentrantní zámek pro vzájemné vyloučení. lock() čeká, pokud zámek drží jiné vlákno; přerušení vlákna toto čekání neukončí. Vlastník může tentýž zámek znovu získat bez čekání. getHoldCount() počítá dosud nevyrovnaná získání aktuálního vlákna, nikoli čekající vlákna; 0 neznamená, že je zámek volný.

unlock() sníží počítadlo o jedna a uvolní zámek až při 0. Pokud ho volá vlákno, které zámek nedrží, vyvolá IllegalMonitorStateException. Hned po každém úspěšném získání vstupte do bloku try a odpovídající unlock() umístěte do finally. Neuvolňujte zámek za pokus, který selhal nebo vyvolal výjimku. Potřebuje-li kód oba zámky, musí je na všech cestách získávat ve stejném pořadí, například gateLock před orderLock, a uvolňovat v opačném pořadí.

tryLock() nečeká: vrátí false, pokud zámek drží jiné vlákno, a true při získání včetně opakovaného vstupu. I u férového zámku může předběhnout čekající vlákna. tryLock(timeout, unit) respektuje pravidla férovosti, pokud jsou zapnutá, čeká nejvýše zadanou dobu (timeout <= 0 znamená bez čekání) a vrátí false, pokud v této době zámek nezíská. Přerušení při vstupu nebo během získávání způsobí InterruptedException a vynuluje příznak přerušení; unit == null je neplatné a způsobí NullPointerException.

Každé volání newCondition() vytvoří samostatný objekt Condition spojený s týmž zámkem. V bufferu s kapacitou jednoho prvku je notEmpty pro konzumenty a notFull pro producenty. Volání signal() bez držení tohoto zámku vyvolá IllegalMonitorStateException. Metoda await() nejprve zkontroluje příznak přerušení aktuálního vlákna. Pokud je už nastavený, vynuluje jej a vyvolá InterruptedException ještě před kontrolou, zda vlákno drží zámek, a bez uvolnění zámku. Jinak await() vyvolá IllegalMonitorStateException, pokud vlákno zámek nedrží. Pokud await() přejde do čekání, atomicky uvolní zámek a před skončením volání jej znovu získá s původním stavem počítadla. Stav ověřujte v cyklu while, protože může nastat falešné probuzení. Signalizujte po změně stavu, dokud ještě držíte zámek; signal() jej neuvolní.

Příklady

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final class Slot {
        private final ReentrantLock lock = new ReentrantLock();
        private final Condition notEmpty = lock.newCondition();
        private final Condition notFull = lock.newCondition();
        private Integer value;

        void put(int item) throws InterruptedException {
            lock.lock();
            try {
                while (value != null) {
                    notFull.await();
                }
                value = item;
                notEmpty.signal();
            } finally {
                lock.unlock();
            }
        }

        int take() throws InterruptedException {
            lock.lock();
            try {
                while (value == null) {
                    notEmpty.await();
                }
                int item = value;
                value = null;
                notFull.signal();
                return item;
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock gateLock = new ReentrantLock();
        ReentrantLock orderLock = new ReentrantLock(true);

        System.out.println(orderLock.getHoldCount());
        orderLock.lock();
        try {
            orderLock.lock();
            try {
                System.out.println(orderLock.getHoldCount());
            } finally {
                orderLock.unlock();
            }
            System.out.println(orderLock.getHoldCount());
            if (orderLock.tryLock()) {
                try {
                    System.out.println(orderLock.getHoldCount());
                } finally {
                    orderLock.unlock();
                }
            }
            System.out.println(orderLock.getHoldCount());
        } finally {
            orderLock.unlock();
        }
        System.out.println(orderLock.getHoldCount());

        gateLock.lock();
        try {
            for (int attempt = 1; attempt <= 2; attempt++) {
                if (!orderLock.tryLock(10, TimeUnit.MILLISECONDS)) {
                    System.out.println("timed " + attempt + ": timeout");
                    continue;
                }
                try {
                    System.out.println("timed " + attempt + ": acquired");
                } finally {
                    orderLock.unlock();
                }
            }
        } finally {
            gateLock.unlock();
        }

        Slot slot = new Slot();
        slot.put(42);
        System.out.println("slot: " + slot.take());
    }
}

Výsledek

0
2
1
2
1
0
timed 1: acquired
timed 2: acquired
slot: 42

Dvě volání `lock()` dají po počáteční `0` první `2`. Jedno `unlock()` ponechá `1` a okamžité `tryLock()` vlastníka vrátí počítadlo na `2`. Dvě zbývající uvolnění dají `1` a `0`. Oba časově omezené pokusy míří na tentýž `orderLock` a uspějí bez soupeření vláken. `put(42)` a `take()` používají samostatné podmínky jednoho zámku bufferu; v tomto běhu ani jedna operace nečeká.

Související lekce

  • Java · Lekce 30 · Pokročilá · Verze: 2
  • Java · Lekce 54 · Středně pokročilá · Verze: 2
  • Java · Lekce 58 · Středně pokročilá · Verze: 2

Zdroje