Esiste un Mutex in Java?

Esiste un oggetto Mutex in java o un modo per crearne uno? Lo chiedo perché un oggetto Semaphore inizializzato con 1 permesso non mi aiuta. Pensa a questo caso:

try {
   semaphore.acquire();
   //do stuff
   semaphore.release();
} catch (Exception e) {
   semaphore.release();
}

se si verifica un'eccezione alla prima acquisizione, il rilascio nel blocco catch aumenterà i permessi e il semaforo non è più un semaforo binario.

Sarà il modo corretto?

try {
   semaphore.acquire();
   //do stuff
} catch (Exception e) {
   //exception stuff
} finally {
   semaphore.release();
}

Il codice precedente garantirà che il semaforo sarà binario?

Vedere questa pagina: http://www.oracle.com/technetwork/articles/javase/index-140767.html

Ha uno schema leggermente diverso che è (penso) quello che stai cercando:

try {
  mutex.acquire();
  try {
    // do something
  } finally {
    mutex.release();
  }
} catch(InterruptedException ie) {
  // ...
}

In questo utilizzo, stai chiamando solo release()dopo un successoacquire()

Qualsiasi oggetto in Java può essere utilizzato come blocco utilizzando un synchronizedblocco. Questo provvederà anche automaticamente a rilasciare il blocco quando si verifica un'eccezione.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Puoi leggere di più su questo qui: Intrinsic Locks and Synchronization

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


private final Lock _mutex = new ReentrantLock(true);

_mutex.lock();

// your protected code here

_mutex.unlock();

Nessuno lo ha menzionato chiaramente, ma questo tipo di pattern di solito non è adatto per i semafori. La ragione è che qualsiasi thread può rilasciare un semaforo, ma di solito si desidera solo il thread proprietario che originariamente bloccata per essere in grado di sbloccare . Per questo caso d'uso, in Java, di solito usiamo ReentrantLocks, che può essere creato in questo modo:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

private final Lock lock = new ReentrantLock(true);

E il solito modello di utilizzo del design è:

  lock.lock();
  try {
      // do something
  } catch (Exception e) {
      // handle the exception
  } finally {
      lock.unlock();
  }

Ecco un esempio nel codice sorgente java in cui puoi vedere questo modello in azione.

Le serrature rientranti hanno l'ulteriore vantaggio di supportare l'equità.

Usa i semafori solo se hai bisogno di una semantica senza rilascio di proprietà.

Penso che dovresti provare con:

Durante l'inizializzazione del semaforo:

Semaphore semaphore = new Semaphore(1, true);

E nel tuo Runnable Implementation

try 
{
   semaphore.acquire(1);
   // do stuff

} 
catch (Exception e) 
{
// Logging
}
finally
{
   semaphore.release(1);
}

L'errore nel post originale è la chiamata acquis () impostata all'interno del ciclo try. Ecco un approccio corretto per utilizzare il semaforo "binario" (Mutex):

semaphore.acquire();
try {
   //do stuff
} catch (Exception e) {
   //exception stuff
} finally {
   semaphore.release();
}

Per assicurarti che a Semaphoresia binario devi solo assicurarti di passare il numero di permessi come 1 quando crei il semaforo. I Javadoc hanno qualche spiegazione in più.

Il blocco di ogni oggetto è leggermente diverso dal design Mutex / Semaphore. Ad esempio, non è possibile implementare correttamente l'attraversamento dei nodi collegati rilasciando il blocco del nodo precedente e catturando quello successivo. Ma con mutex è facile implementare:

Node p = getHead();
if (p == null || x == null) return false;
p.lock.acquire();  // Prime loop by acquiring first lock.
// If above acquire fails due to interrupt, the method will
//   throw InterruptedException now, so there is no need for
//   further cleanup.
for (;;) {
Node nextp = null;
boolean found;
try { 
 found = x.equals(p.item); 
 if (!found) { 
   nextp = p.next; 
   if (nextp != null) { 
     try {      // Acquire next lock 
                //   while still holding current 
       nextp.lock.acquire(); 
     } 
     catch (InterruptedException ie) { 
      throw ie;    // Note that finally clause will 
                   //   execute before the throw 
     } 
   } 
 } 
}finally {     // release old lock regardless of outcome 
   p.lock.release();
} 

Attualmente, non esiste una classe di questo tipo java.util.concurrent, ma puoi trovare l'implementazione di Mutext qui Mutex.java . Per quanto riguarda le librerie standard, Semaphore fornisce tutte queste funzionalità e molto altro ancora.