Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

Lock — izrecno pridobivanje in sproščanje zaklepa

Vmesnik java.util.concurrent.locks.Lock omogoča izrecno upravljanje zaklepanja. Spoznajte par lock()/unlock(), varen vzorec try/finally in primer, v katerem ReentrantLock ščiti skupni števec.

Različica: Java SE 21; repository runtime, production runtime not attested

Sintaksa

Lock lock = new ReentrantLock();
lock.lock();
try {
    // protected operations
} finally {
    lock.unlock();
}

java.util.concurrent.locks.Lock je vmesnik za izrecno zaklepanje; ReentrantLock je njegova implementacija, ki zagotavlja medsebojno izključevanje in omogoča ponovni vstop iste niti. Teh lastnosti nima nujno vsaka implementacija Lock.

Lock.lock() pridobi zaklep in po potrebi počaka; Lock.unlock() ga sprosti. lock.lock() pokličite pred try, lock.unlock() pa v finally. Za razliko od synchronized sproščanje ni samodejno. finally zagotovi sprostitev tudi, če v zaščiteni kodi pride do izjeme.

Vsi sočasni dostopi do zaščitenega stanja morajo upoštevati isti protokol zaklepanja. Ko nit, ki zaklepa še ne drži, zaklep uspešno pridobi, je učinek na sinhronizacijo pomnilnika enak kot pri pridobitvi monitorja. Uspešna popolna sprostitev zaklepa ima enak učinek kot sprostitev monitorja. Lock ne zahteva učinkov sinhronizacije pomnilnika pri neuspešnih operacijah niti pri ponovni pridobitvi zaklepa s strani niti, ki ga že drži, in pri pripadajoči sprostitvi. synchronized (lock) ne nadomesti lock.lock().

Pri ReentrantLock mora vsakemu pridobivanju ustrezati sprostitev; če unlock() pokliče nit, ki zaklepa ne drži, se sproži IllegalMonitorStateException. Vmesnik ponuja tudi tryLock() in lockInterruptibly() za druge strategije čakanja.

Primer uporablja en skupni zaklep za obe operaciji count++. Po obeh klicih join() program izpiše 2, ne glede na vrstni red izvajanja niti. Obseg dokumentacije: Java SE 21; izvajalno okolje repozitorija in produkcijsko izvajalno okolje nista potrjena.

Primeri

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);
    }
}

Rezultat

2

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri