Existe um Mutex em Java?

Existe um objeto Mutex em java ou uma maneira de criar um? Estou perguntando porque um objeto Semaphore inicializado com 1 licença não me ajuda. Pense neste caso:

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

se ocorrer uma exceção na primeira aquisição, a liberação no bloco catch aumentará as permissões e o semáforo não será mais um semáforo binário.

Será a maneira correta?

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

O código acima garantirá que o semáforo será binário?

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

Tem um padrão ligeiramente diferente que é (eu acho) o que você está procurando:

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

Nesse uso, você só está ligando release()depois de umacquire()

Qualquer objeto em Java pode ser usado como um bloqueio usando um synchronizedbloco. Isso também irá automaticamente liberar o bloqueio quando ocorrer uma exceção.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Você pode ler mais sobre isso aqui: Bloqueios intrínsecos e sincronização

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

Ninguém mencionou isso claramente, mas esse tipo de padrão geralmente não é adequado para semáforos. O motivo é que qualquer thread pode liberar um semáforo, mas normalmente você só deseja que o thread do proprietário que foi bloqueado originalmente seja desbloqueado . Para este caso de uso, em Java, geralmente usamos ReentrantLocks, que pode ser criado assim:

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

private final Lock lock = new ReentrantLock(true);

E o padrão de design usual de uso é:

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

Aqui está um exemplo no código-fonte java onde você pode ver esse padrão em ação.

Os bloqueios reentrantes têm o benefício adicional de apoiar a justiça.

Use semáforos apenas se precisar de uma semântica de liberação sem propriedade.

Eu acho que você deveria tentar com:

Durante a inicialização do Semaphore:

Semaphore semaphore = new Semaphore(1, true);

E no seu Runnable Implementation

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

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

O erro na postagem original é a chamada purchase () definida dentro do loop try. Aqui está uma abordagem correta para usar semáforo "binário" (Mutex):

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

Para garantir que a Semaphoreseja binário, você só precisa passar o número de licenças como 1 ao criar o semáforo. Os Javadocs têm um pouco mais de explicação.

O bloqueio de cada objeto é um pouco diferente do design Mutex / Semaphore. Por exemplo, não há maneira de implementar corretamente o cruzamento de nós vinculados com a liberação do bloqueio do nó anterior e a captura do próximo. Mas com mutex é 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();
} 

Atualmente, não existe essa classe em java.util.concurrent, mas você pode encontrar a implementação de Mutext aqui Mutex.java . Quanto às bibliotecas padrão, o Semaphore fornece todas essas funcionalidades e muito mais.