[JAVA] Lock and condition

[franksisca]

Sono i metodi di sincronizzazione della tiger, chi me li spiega con qualche esempietto

[PGI-Bis]

Tra (ReentrantLock,Condition) e (synchronized/wait-notify) la differenza più notevole è quella sintattica: per sincronizzare con java.util.concurrent vedi scrivere molta più roba.

L'altra è strutturale: ReentrantLock e Condition "circolano", nel senso che possono provenire da una parte del sistema diversa da quella che li usa. Gli altri due, synchronized e wait-notify, non passano da una parte all'altra in sè ma possono girovagare insieme all'oggetto che fa da monitor.

Ciò che si è fatto con ReentrantLock e Condition è stato semplicemente prendere alcune proprietà di ogni oggetto Java precedentemente espresse attraverso una sintassi ad hoc del linguaggio e travasarle in metodi ad hoc di oggetti ad hoc.

Così se prima:

private final Object MONITOR = new Object();
public void metodo() {
    synchronized(MONITOR) {//chiudi
        bubbole();
    }//apri
}

ora:

private final Lock MONITOR = new ReentrantLock();
public void metodo() {
    try {
        MONITOR.lock();//chiudi
        bubbole();
    } finally {
        MONITOR.unlock();//apri
    }
}

Se prima:

private final Object MONITOR = new Object();

public Resource getResource() {
    synchronized(MONITOR) {
        try {
            while(resources.size() == 0) {
                wait();
            }
        } catch(InterruptedException ex) {
            return null;
        }
    }
}

private void createResource() {
    synchronized(MONITOR) {
        resources.put(some);
        notifyAll();
    }
}

ora:

private final Lock MONITOR = new ReentrantLock();
private Condition storeCondition = MONITOR.newCondition();

public Resource getResource() {
    try {
        MONITOR.lock();
        try {
            while(resources.size() == 0) {
                storeCondition.await();
            }
        } catch(InterruptedException ex) {
            return null;
        }
    } finally {
        MONITOR.unlock();
    }
}

private void createResource() {
    try {
        MONITOR.lock();
        resources.put(some);
        storeCondition.signalAll();
    } finally {
        MONITOR.unlock();
    }
}

Ci sono poi alcuni ricami. Ad esempio, rispetto alla sincronizzazione, un ReentrantLock può vedere interrotto il suo tentativo di acquisire il lock se anzichè MONITOR.lock() usi MONITOR.lockInterruptibly(). Rispetto al wait, Condition ha la possibilità di attendere a prescindere da un'eventuale interruzione del Thread. Sono due necessità comuni che prima richiedevano un gruppo di istruzioni e ora sono incapsulate in due comportamenti unitari.

Niente per cui andare in giro strappandosi i capelli e gridando "oh gesummaria l'ha fatto che bello che bello!" ma, sai, son quelle piccole comodità che uno apprezza.

[franksisca]

supponevo che mi avresti risposto tu

Ok, credo di avere capito, casomai ti chiamo