Y a-t-il un Mutex en Java ?

Question

Existe-t-il un objet Mutex en java ou un moyen d'en créer un ? Je demande car un objet Sémaphore initialisé avec 1 permis ne m'aide pas. Pensez à ce cas :

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

si une exception se produit à la première acquisition, le release dans le bloc catch augmentera les permis, et le sémaphore n'est plus un sémaphore binaire.

Est-ce que la manière correcte sera ?

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

Le code ci-dessus garantit-il que le sémaphore sera binaire ?

Answer 1

Tout objet en Java peut être utilisé comme verrou à l'aide d'une balise synchronized bloc. Cela permettra également de libérer automatiquement le verrou lorsqu'une exception se produit.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Vous pouvez en savoir plus à ce sujet ici : Verrous intrinsèques et synchronisation

Answer 2

Voir cette page : http://www.oracle.com/technetwork/articles/javase/index-140767.html

Il présente un motif légèrement différent qui correspond (je pense) à ce que vous recherchez :

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

Dans cette utilisation, vous appelez seulement release() après un succès acquire()

Answer 3

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();

Answer 4

Pour garantir qu'un Semaphore est binaire, il suffit de s'assurer que le nombre de permis est égal à 1 lors de la création du sémaphore. Le site Javadocs ont un peu plus d'explications.

Answer 5

Le verrouillage de chaque objet est légèrement différent de la conception de Mutex/Semaphore. Par exemple, il n'y a aucun moyen d'implémenter correctement la traversée de nœuds liés en libérant le verrou du nœud précédent et en capturant le suivant. Mais avec un mutex, c'est facile à mettre en œuvre :

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();
} 

Actuellement, il n'y a pas de classe de ce type dans java.util.concurrent mais vous pouvez trouver l'implémentation de Mutext ici Mutex.java . Quant aux bibliothèques standard, Semaphore fournit toutes ces fonctionnalités et bien plus encore.