Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

Metódy ReentrantLock: získanie zámku, opakovaný vstup a podmienky

Rozlíšte blokujúce `lock()` a dve preťaženia `tryLock()`, ku každému úspešnému získaniu priraďte `unlock()` a používajte samostatné podmienky jedného zámku.

Verzia: Java SE 21

Syntax

// 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ámok na vzájomné vylúčenie. lock() čaká, ak zámok drží iné vlákno; prerušenie vlákna toto čakanie neukončí. Vlastník môže ten istý zámok získať znova bez čakania. getHoldCount() počíta doteraz nevyvážené získania aktuálneho vlákna, nie čakajúce vlákna; 0 neznamená, že je zámok voľný.

unlock() zníži počítadlo o jeden a uvoľní zámok až pri 0. Ak ho volá vlákno, ktoré zámok nedrží, vyvolá IllegalMonitorStateException. Hneď po každom úspešnom získaní vstúpte do bloku try a zodpovedajúce unlock() vložte do finally. Neuvoľňujte zámok za pokus, ktorý zlyhal alebo vyvolal výnimku. Keď kód potrebuje oba zámky, získavajte ich na každej ceste v rovnakom poradí, napríklad gateLock pred orderLock, a uvoľňujte ich v opačnom poradí.

tryLock() nečaká: vráti false, ak zámok drží iné vlákno, a true pri získaní vrátane opakovaného vstupu. Aj pri férovom zámku môže predbehnúť čakajúce vlákna. tryLock(timeout, unit) rešpektuje pravidlá férovosti, ak sú zapnuté, čaká najviac zadaný čas (timeout <= 0 znamená bez čakania) a vráti false, ak v tomto čase zámok nezíska. Prerušenie pri vstupe alebo počas získavania spôsobí InterruptedException a vymaže príznak prerušenia; unit == null je neplatné a spôsobí NullPointerException.

Každé volanie newCondition() vytvorí samostatný objekt Condition viazaný na ten istý zámok. V jednoprvkovej vyrovnávacej pamäti je notEmpty pre spotrebiteľov a notFull pre producentov. Volanie signal() bez držania zámku vyvolá IllegalMonitorStateException. Metóda await() najprv skontroluje príznak prerušenia aktuálneho vlákna. Ak je už nastavený, vymaže ho a vyvolá InterruptedException ešte pred kontrolou, či vlákno drží zámok, a bez uvoľnenia zámku. Inak await() vyvolá IllegalMonitorStateException, ak vlákno zámok nedrží. Ak await() prejde do čakania, atomicky uvoľní zámok a pred skončením volania ho znova získa s pôvodnou hodnotou počítadla. Stav kontrolujte v cykle while, pretože môže dôjsť k falošnému prebudeniu. Signalizujte po zmene stavu, kým ešte držíte zámok; signal() ho neuvoľní.

Prí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ýsledok

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

Dve volania `lock()` dajú po úvodnej `0` prvú `2`. Jedno `unlock()` ponechá `1` a okamžité `tryLock()` vlastníka vráti počítadlo na `2`. Dve zostávajúce uvoľnenia dajú `1` a `0`. Oba časovo obmedzené pokusy používajú ten istý `orderLock` a uspejú bez súperenia vlákien. `put(42)` a `take()` používajú samostatné podmienky jedného zámku vyrovnávacej pamäte; pri tomto spustení ani jedna operácia nečaká.

Súvisiace lekcie

  • Java · Lekcia 30 · Pokročilá · Verzia: 2
  • Java · Lekcia 54 · Stredne pokročilá · Verzia: 2
  • Java · Lekcia 58 · Stredne pokročilá · Verzia: 2

Zdroje