ReentrantLock e synchronized a confronto
Confronti le funzionalità di ReentrantLock (tryLock, lockInterruptibly, fairness) con la parola chiave synchronized.
ReentrantLock e synchronized a confronto è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
La parola chiave synchronized
La parola chiave synchronized di Java fornisce l'esclusione reciproca usando il lock intrinseco dell'oggetto (monitor). È semplice, ma limitata: nessun timeout, nessuna fairness e nessuna possibilità di interruzione.
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()Nozioni di base su ReentrantLock
ReentrantLock è un lock esplicito del package java.util.concurrent.locks. Fornisce la stessa esclusione reciproca di synchronized, ma con un controllo maggiore. Il lock deve essere rilasciato manualmente in un blocco finally.
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: acquisizione non bloccante
tryLock() tenta di acquisire il lock senza bloccare il thread. Restituisce true se l'acquisizione riesce e false se il lock è detenuto da un altro thread.
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 con timeout
Attendere fino al tempo specificato per acquisire il lock:
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() acquisisce il lock a meno che il thread non venga interrotto; è utile per le attività annullabili in attesa di un lock:
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();
}Rientranza
Sia synchronized sia ReentrantLock sono rientranti: un thread che detiene già il lock può acquisirlo nuovamente senza causare un 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 releasedPolitica di fairness
Creare un ReentrantLock fair per concedere l'accesso in ordine FIFO: questo impedisce la starvation dei thread, al costo di un throughput inferiore:
// 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()); // trueVariabili Condition
ReentrantLock fornisce oggetti Condition, più flessibili di 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(); }Quando usare ReentrantLock invece di synchronized
Usare synchronized quando:
- È necessaria una semplice esclusione reciproca
- Non sono richiesti timeout, fairness o possibilità di interruzione
Usare ReentrantLock quando:
- È necessario usare tryLock() o tryLock(timeout)
- È necessario usare lockInterruptibly()
- È richiesto un ordinamento fair
- Sono necessarie più variabili Condition
Conteggio dei lock e monitoraggio
ReentrantLock fornisce metodi diagnostici:
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 releasedErrore comune: sbloccare senza aver acquisito il lock
Chiamare unlock() quando il thread corrente non detiene il lock genera IllegalMonitorStateException. Abbinare sempre lock e unlock oppure usare 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!");
}Verifica rapida
Quale metodo di ReentrantLock consente a un thread di acquisire il lock oppure di restituire immediatamente il controllo senza bloccarsi se il lock non è disponibile?
Riepilogo: ReentrantLock e synchronized
Punti chiave:
- Entrambi forniscono esclusione reciproca e rientranza
- ReentrantLock aggiunge: tryLock, lockInterruptibly, fairness e Condition
- Rilasciare sempre il lock in un blocco finally
- synchronized è più semplice: preferirlo quando le sue funzionalità sono sufficienti
- Usare ReentrantLock negli scenari avanzati: timeout, possibilità di interruzione e più Condition
Domande Frequenti
La lezione «ReentrantLock e synchronized a confronto» è gratuita?
Sì — il testo completo di «ReentrantLock e synchronized a confronto» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «ReentrantLock e synchronized a confronto»?
Confronti le funzionalità di ReentrantLock (tryLock, lockInterruptibly, fairness) con la parola chiave synchronized. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «ReentrantLock e synchronized a confronto»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- ReentrantLock e synchronized a confronto
- ReadWriteLock per scenari lettore-scrittore
- Variabili atomiche: aggiornamenti senza lock
- StampedLock e letture ottimistiche