CKTIS / Java
Lock — explicitné získanie a uvoľnenie zámku
Rozhranie java.util.concurrent.locks.Lock umožňuje explicitne ovládať zamykanie. Spoznajte dvojicu lock()/unlock(), bezpečný vzor try/finally a príklad, v ktorom ReentrantLock chráni zdieľaný čítač.
Verzia: Java SE 21; repository runtime, production runtime not attested
Syntax
Lock lock = new ReentrantLock();
lock.lock();
try {
// protected operations
} finally {
lock.unlock();
}java.util.concurrent.locks.Lock je rozhranie na explicitné zamykanie; ReentrantLock je implementácia, ktorá poskytuje vzájomné vylúčenie a opätovný vstup tým istým vláknom. Nie každá implementácia Lock musí mať tieto vlastnosti.
Lock.lock() získa zámok a v prípade potreby čaká; Lock.unlock() ho uvoľní. Zavolajte lock.lock() pred try a lock.unlock() v finally. Na rozdiel od synchronized sa zámok neuvoľní automaticky. finally zabezpečí uvoľnenie aj vtedy, keď v chránenom kóde dôjde k výnimke.
Všetky súbežné prístupy k chránenému stavu musia dodržiavať rovnaký protokol zamykania. Ak zámok úspešne získa vlákno, ktoré ho ešte nedrží, má to rovnaký účinok na synchronizáciu pamäte ako získanie monitora. Úspešné úplné uvoľnenie zámku má rovnaký účinok ako uvoľnenie monitora. Rozhranie Lock nevyžaduje účinky synchronizácie pamäte pri neúspešných operáciách ani pri opätovnom získaní zámku vláknom, ktoré ho už drží, a pri zodpovedajúcom uvoľnení. synchronized (lock) nenahrádza lock.lock().
Pri ReentrantLock musí každému získaniu zodpovedať uvoľnenie; ak unlock() zavolá vlákno, ktoré zámok nedrží, vyvolá sa IllegalMonitorStateException. Rozhranie ponúka aj tryLock() a lockInterruptibly() na iné stratégie čakania.
Príklad používa jeden zdieľaný zámok pre obe operácie count++. Po oboch volaniach join() program vypíše 2 bez ohľadu na poradie vykonávania vlákien. Rozsah dokumentácie: Java SE 21; behové prostredie repozitára ani produkčné behové prostredie nie sú potvrdené.
Príklady
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private static final Lock lock = new ReentrantLock();
private static int count = 0;
private static void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Thread first = new Thread(Main::increment);
Thread second = new Thread(Main::increment);
first.start();
second.start();
first.join();
second.join();
System.out.println(count);
}
}Výsledok
2
Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.