[JAVA] Domanda ReentrantLock

[starfred]

Vengo subito al dunque:
Ho una classe dove eseguo (pseudocodice)

class sem{
ReentrantLock lock;
...

void blocca(){
....
lock.lock();
...

}

void sblocca(){
....
lock.unlock();
...

}
}

il problema è che, poiché la classe è condivisa da più thread, quando fanno la unlock viene sollevata l'eccezione

java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:127)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1175)
at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:431)

Da quel che ho capito il problema nasce dal fatto che il thread che ha eseguito la lock non è quello che esegue la unlock, almeno così io ho capito.
Come faccio a risolvere? :D

ciao e grazie

[banryu79]

Da quel che ho capito il problema nasce dal fatto che il thread che ha eseguito la lock non è quello che esegue la unlock, almeno così io ho capito.
Come faccio a risolvere? :D

Esatto, solo il thread che ha acquisito il lock può rialsciarlo (ha senso no?), non è mica un semaforo.

Di solito si utilizzano in questo modo (esempio idiomatico preso dai javadoc) :

class X {
private final ReentrantLock lock = new ReentrantLock();
// ...

public void m() {
lock.lock(); // block until condition holds
try {
// ... method body
} finally {
lock.unlock()
}
}
}

E' praticamente obbligatorio acquisire e rilascaire il lock utilizzando il costrutto try - finally...

[starfred]

Esatto, solo il thread che ha acquisito il lock può rialsciarlo (ha senso no?), non è mica un semaforo.

Come no? Io li utilizzavo come semafori :doh:


E' praticamente obbligatorio acquisire e rilascaire il lock utilizzando il costrutto try - finally...

Quindi non c'è modo volendo di spezzare quella funzione in due funzioni distinte?

[banryu79]

Come no? Io li utilizzavo come semafori :doh:
Quindi non c'è modo volendo di spezzare quella funzione in due funzioni distinte?
Beh, ma se ti serve la semantica di un semaforo allora usa un java.util.concurrent.Semaphore, no?
Esempio presente nei javadoc di Semaphore:

class Pool {
private static final int MAX_AVAILABLE = 100;
private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

public Object getItem() throws InterruptedException {
available.acquire();
return getNextAvailableItem();
}

public void putItem(Object x) {
if (markAsUnused(x))
available.release();
}

// Not a particularly efficient data structure; just for demo

protected Object[] items = ... whatever kinds of items being managed
protected boolean[] used = new boolean[MAX_AVAILABLE];

protected synchronized Object getNextAvailableItem() {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (!used[i]) {
used[i] = true;
return items[i];
}
}
return null; // not reached
}

protected synchronized boolean markAsUnused(Object item) {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (item == items[i]) {
if (used[i]) {
used[i] = false;
return true;
} else
return false;
}
}
return false;
}

}