Existe-t-il un Mutex en Java?

Existe-t-il un objet Mutex en java ou un moyen d'en créer un? Je demande parce qu'un objet Semaphore 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 lors de la première acquisition, la libération dans le bloc catch augmentera les autorisations et le sémaphore n'est plus un sémaphore binaire.

La bonne manière sera-t-elle?

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

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

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

Il a un motif légèrement différent qui est (je pense) ce que vous recherchez:

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

Dans cet usage, vous n'appelez release()qu'après un succèsacquire()

Tout objet en Java peut être utilisé comme verrou à l'aide d'un synchronizedbloc. Cela prendra également en charge automatiquement la libération du verrou lorsqu'une exception se produit.

Object someObject = ...;

synchronized (someObject) {
  ...
}

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

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

Personne ne l'a clairement mentionné, mais ce type de modèle n'est généralement pas adapté aux sémaphores. La raison est que tout thread peut libérer un sémaphores, mais vous ne voulez généralement que le thread propriétaire que verrouillé à l' origine pour pouvoir déverrouiller . Pour ce cas d'utilisation, en Java, nous utilisons généralement ReentrantLocks, qui peuvent être créés comme ceci:

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

private final Lock lock = new ReentrantLock(true);

Et le modèle d'utilisation habituel est:

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

Voici un exemple dans le code source java où vous pouvez voir ce modèle en action.

Les verrous réentrants présentent l'avantage supplémentaire de favoriser l'équité.

N'utilisez des sémaphores que si vous avez besoin d'une sémantique sans propriété.

Je pense que vous devriez essayer avec:

Pendant l'initialisation du sémaphore:

Semaphore semaphore = new Semaphore(1, true);

Et dans votre Runnable Implementation

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

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

L'erreur dans le message d'origine est un appel acquise () défini dans la boucle try. Voici une approche correcte pour utiliser le sémaphore "binaire" (Mutex):

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

Pour vous assurer que a Semaphoreest binaire, vous devez simplement vous assurer que vous passez le nombre de permis à 1 lors de la création du sémaphore. Les Javadocs ont un peu plus d'explications.

Le verrou de chaque objet est peu différent de la conception Mutex / Semaphore. Par exemple, il n'existe aucun moyen d'implémenter correctement la traversée des nœuds liés en libérant le verrou du nœud précédent et en capturant le suivant. Mais avec mutex, il est facile de 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'existe 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.