¿Existe un mutex en Java?

¿Hay un objeto Mutex en Java o una forma de crear uno? Lo pregunto porque un objeto Semaphore inicializado con 1 permiso no me ayuda. Piense en este caso:

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

si ocurre una excepción en la primera adquisición, la liberación en el bloque de captura aumentará los permisos y el semáforo ya no es un semáforo binario.

¿Será la forma correcta?

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

¿El código anterior asegurará que el semáforo sea binario?

Consulte esta página: http://www.oracle.com/technetwork/articles/javase/index-140767.html

Tiene un patrón ligeramente diferente que es (creo) lo que estás buscando:

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

En este uso, solo está llamando release()después de una exitosaacquire()

Cualquier objeto en Java se puede utilizar como bloqueo mediante un synchronizedbloque. Esto también se encargará automáticamente de liberar el bloqueo cuando ocurra una excepción.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Puede leer más sobre esto aquí: Bloqueos intrínsecos y sincronización

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

Nadie ha mencionado esto claramente, pero este tipo de patrón generalmente no es adecuado para semáforos. La razón es que cualquier hilo puede liberar un semáforo, pero normalmente solo desea que el hilo propietario que originalmente se bloqueó pueda desbloquearse . Para este caso de uso, en Java, usualmente usamos ReentrantLocks, que se puede crear así:

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

private final Lock lock = new ReentrantLock(true);

Y el patrón de diseño habitual de uso es:

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

Aquí hay un ejemplo en el código fuente de Java donde puede ver este patrón en acción.

Las cerraduras reentrantes tienen el beneficio adicional de apoyar la equidad.

Use semáforos solo si necesita una semántica que no sea de liberación de propiedad.

Creo que deberías probar con:

Durante la inicialización del semáforo:

Semaphore semaphore = new Semaphore(1, true);

Y en tu Runnable Implementation

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

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

El error en la publicación original es el conjunto de llamadas adquisiciones () dentro del bucle try. Aquí hay un enfoque correcto para usar un semáforo "binario" (Mutex):

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

Para asegurarse de que a Semaphoresea ​​binario, solo debe asegurarse de pasar el número de permisos como 1 al crear el semáforo. Los Javadocs tienen un poco más de explicación.

El bloqueo de cada objeto es un poco diferente del diseño Mutex / Semaphore. Por ejemplo, no hay forma de implementar correctamente el desplazamiento de nodos vinculados liberando el bloqueo del nodo anterior y capturando el siguiente. Pero con mutex es fácil de implementar:

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

Actualmente, no existe tal clase en java.util.concurrent, pero puede encontrar la implementación de Mutext aquí Mutex.java . En cuanto a las bibliotecas estándar, Semaphore proporciona toda esta funcionalidad y mucho más.