KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Lock — expliciet vergrendelen en ontgrendelen

De interface java.util.concurrent.locks.Lock biedt expliciete controle over vergrendeling. Leer het paar lock()/unlock(), het veilige try/finally-patroon en een voorbeeld waarin ReentrantLock een gedeelde teller beschermt.

Versie: 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 is een interface voor expliciete vergrendeling; ReentrantLock is een implementatie die wederzijdse uitsluiting biedt en opnieuw betreden door dezelfde thread mogelijk maakt. Niet elke Lock-implementatie hoeft deze eigenschappen te hebben.

Lock.lock() verwerft de lock en wacht zo nodig; Lock.unlock() geeft deze vrij. Roep lock.lock() aan vóór try en lock.unlock() in finally. Anders dan bij synchronized gebeurt vrijgeven niet automatisch. finally zorgt ook voor vrijgave als er een uitzondering optreedt in de beschermde code.

Alle gelijktijdige toegangen tot de beschermde toestand moeten hetzelfde vergrendelingsprotocol volgen. Als een thread met succes een lock verwerft die hij nog niet bezit, heeft dat voor de geheugensynchronisatie hetzelfde effect als het verwerven van een monitor. Het succesvol volledig vrijgeven van de lock heeft hetzelfde effect als het vrijgeven van een monitor. Lock vereist geen geheugensynchronisatie-effecten voor mislukte bewerkingen of voor herhaalde verwervingen door een thread die de lock al bezit en de bijbehorende vrijgaven. synchronized (lock) vervangt lock.lock() niet.

Bij ReentrantLock moet elke verwerving een bijbehorende vrijgave hebben; roept een thread die de lock niet bezit unlock() aan, dan wordt IllegalMonitorStateException gegenereerd. De interface biedt ook tryLock() en lockInterruptibly() voor andere wachtstrategieën.

Het voorbeeld gebruikt één gedeelde lock voor beide count++-bewerkingen. Na beide aanroepen van join() drukt het programma 2 af, ongeacht de uitvoeringsvolgorde van de threads. Documentatiebereik: Java SE 21; de runtime van de repository en de productie-runtime zijn niet bevestigd.

Voorbeelden

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

Resultaat

2

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen