[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?

ciao e grazie

[banryu79]

Originariamente inviato da starfred

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?

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]

Originariamente inviato da banryu79

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

Originariamente inviato da banryu79

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]

Originariamente inviato da starfred

Come no? Io li utilizzavo come semafori
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;
   }

 }