Java Academy · leksjon

ReentrantLock kontra synchronized

Sammenlign funksjonene i ReentrantLock (tryLock, lockInterruptibly, fairness) med nøkkelordet synchronized.

Leksjon 1 av 413 trinn

ReentrantLock kontra synchronized er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Nøkkelordet synchronized

Javas synchronized-nøkkelord gir gjensidig utelukkelse ved hjelp av objektets innebygde lås (monitor). Det er enkelt, men begrenset — ingen tidsavbrudd, rettferdighet eller mulighet for avbrytelser.

class Counter {
    private int count = 0;
    
    synchronized void increment() {
        count++; // only one thread at a time
    }
    
    synchronized int get() { return count; }
}

Counter c = new Counter();
// Multiple threads can safely call increment()

Grunnleggende om ReentrantLock

ReentrantLock er en eksplisitt lås fra java.util.concurrent.locks. Den gir samme gjensidige utelukkelse som synchronized, men med mer kontroll. Låsen må frigjøres manuelt i en finally-blokk.

import java.util.concurrent.locks.*;

class SafeCounter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // always release in finally!
        }
    }
    
    int get() {
        lock.lock();
        try { return count; }
        finally { lock.unlock(); }
    }
}

tryLock: Ikke-blokkerende låsing

tryLock() forsøker å skaffe låsen uten å blokkere. Returnerer true hvis det lykkes, og false hvis låsen holdes av en annen tråd.

ReentrantLock lock = new ReentrantLock();

if (lock.tryLock()) {
    try {
        System.out.println("Got the lock, doing work");
    } finally {
        lock.unlock();
    }
} else {
    System.out.println("Lock busy, skipping or retrying");
}

tryLock med tidsavbrudd

Vent i opptil en angitt tid på å skaffe låsen:

try {
    if (lock.tryLock(500, TimeUnit.MILLISECONDS)) {
        try {
            // work with protected resource
            System.out.println("Acquired within 500ms");
        } finally {
            lock.unlock();
        }
    } else {
        System.out.println("Timed out waiting for lock");
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

lockInterruptibly

lockInterruptibly() skaffer låsen med mindre tråden blir avbrutt — nyttig for avbrytbare oppgaver som venter på en lås:

try {
    lock.lockInterruptibly(); // throws InterruptedException if interrupted
    try {
        // do work
    } finally {
        lock.unlock();
    }
} catch (InterruptedException e) {
    System.out.println("Interrupted while waiting for lock");
    Thread.currentThread().interrupt();
}

Reentrans

Både synchronized og ReentrantLock er reentrant — en tråd som allerede holder låsen, kan skaffe den på nytt uten å føre til deadlock:

synchronized void outer() {
    System.out.println("outer");
    inner(); // same thread re-enters — OK
}

synchronized void inner() {
    System.out.println("inner"); // same lock, same thread
}

// ReentrantLock:
ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.lock(); // acquire again — hold count = 2
lock.unlock(); // hold count = 1
lock.unlock(); // hold count = 0, lock released

Rettferdighetspolicy

Opprett en rettferdig ReentrantLock for å gi tilgang i FIFO-rekkefølge — hindrer trådsulting på bekostning av lavere gjennomstrømning:

// Unfair (default): no ordering guarantee, better throughput
ReentrantLock unfair = new ReentrantLock();

// Fair: threads acquire in arrival order
ReentrantLock fair = new ReentrantLock(true);

System.out.println(fair.isFair()); // true

Betingelsesvariabler

ReentrantLock tilbyr Condition-objekter — mer fleksible enn wait()/notify():

ReentrantLock lock2 = new ReentrantLock();
Condition notEmpty = lock2.newCondition();
Queue<String> queue = new LinkedList<>();

// Producer
lock2.lock();
try {
    queue.offer("item");
    notEmpty.signal(); // wake one waiting thread
} finally { lock2.unlock(); }

// Consumer
lock2.lock();
try {
    while (queue.isEmpty()) notEmpty.await(); // wait & release lock
    System.out.println(queue.poll());
} finally { lock2.unlock(); }

Når bør ReentrantLock brukes i stedet for synchronized

Bruk synchronized når:

Du trenger enkel gjensidig utelukkelse
Du ikke trenger tidsavbrudd, rettferdighet eller mulighet for avbrytelser

Bruk ReentrantLock når:

Du trenger tryLock() eller tryLock(timeout)
Du trenger lockInterruptibly()
Du trenger rettferdig rekkefølge
Du trenger flere Condition-variabler

Låsetelling og overvåking

ReentrantLock tilbyr diagnostiske metoder:

ReentrantLock lock3 = new ReentrantLock();
lock3.lock();
lock3.lock(); // reentrant — hold count 2

System.out.println(lock3.getHoldCount());    // 2
System.out.println(lock3.isHeldByCurrentThread()); // true
System.out.println(lock3.isLocked());        // true
System.out.println(lock3.getQueueLength());  // 0 (no waiting threads)

lock3.unlock();
lock3.unlock(); // fully released

Vanlig feil: Låse opp uten å ha låst

Hvis du kaller unlock() når den gjeldende tråden ikke holder låsen, kastes IllegalMonitorStateException. Koble alltid sammen lock og unlock, eller bruk try-finally:

ReentrantLock lock4 = new ReentrantLock();
try {
    // If lock() is never called (e.g., skipped by exception before this line)
    lock4.unlock(); // throws IllegalMonitorStateException
} catch (IllegalMonitorStateException e) {
    System.out.println("Must lock before unlock!");
}

Hurtigsjekk

Hvilken ReentrantLock-metode gjør det mulig for en tråd å skaffe låsen eller returnere umiddelbart uten å blokkere hvis låsen ikke er tilgjengelig?

Besvar den i den interaktive leksjonen

Oppsummering: ReentrantLock vs synchronized

Viktigste punkter:

Begge gir gjensidig utelukkelse og reentrans
ReentrantLock legger til: tryLock, lockInterruptibly, rettferdighet og Conditions
Frigjør alltid låsen i en finally-blokk
synchronized er enklere — foretrekk det når funksjonene er tilstrekkelige
Bruk ReentrantLock i avanserte scenarier: tidsavbrudd, avbrytbarhet og flere betingelser

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «ReentrantLock kontra synchronized» gratis?

Ja – hele teksten i «ReentrantLock kontra synchronized» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «ReentrantLock kontra synchronized»?

Sammenlign funksjonene i ReentrantLock (tryLock, lockInterruptibly, fairness) med nøkkelordet synchronized. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «ReentrantLock kontra synchronized»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

ReentrantLock kontra synchronized
ReadWriteLock for leser-skriver-scenarioer
Atomiske variabler: oppdateringer uten låser
StampedLock og optimistiske lesinger

← Tilbake til Java Academy