Czy w Javie jest Mutex?

Czy istnieje obiekt Mutex w Javie lub sposób na jego utworzenie? Pytam, ponieważ obiekt Semaphore zainicjowany z 1 zezwoleniem mi nie pomaga. Pomyśl o tym przypadku:

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

jeśli wyjątek wystąpi przy pierwszym pobraniu, zwolnienie w bloku catch zwiększy zezwolenia, a semafor nie jest już semaforem binarnym.

Czy będzie właściwy sposób?

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

Czy powyższy kod zapewni, że semafor będzie binarny?

Zobacz tę stronę: http://www.oracle.com/technetwork/articles/javase/index-140767.html

Ma nieco inny wzór, który jest (chyba) tym, czego szukasz:

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

W tym przypadku dzwonisz tylko release()po pomyślnym zakończeniuacquire()

Każdy obiekt w Javie może być używany jako blokada za pomocą synchronizedbloku. Spowoduje to również automatyczne zwolnienie blokady, gdy wystąpi wyjątek.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Możesz przeczytać więcej na ten temat tutaj: Wewnętrzne blokady i synchronizacja

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

Nikt o tym wyraźnie nie wspomniał, ale ten typ wzoru zwykle nie jest odpowiedni dla semaforów. Powodem jest to, że każdy wątek może zwolnić semafor, ale zwykle potrzebujesz tylko wątku właściciela który był pierwotnie zablokowany, mógł odblokować . W tym przypadku w Javie zwykle używamy ReentrantLocks, które można utworzyć w następujący sposób:

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

private final Lock lock = new ReentrantLock(true);

A typowy wzór użytkowania to:

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

Oto przykład w kodzie źródłowym Java, w którym można zobaczyć ten wzorzec w akcji.

Dodatkową zaletą blokad reentrantowych jest wspieranie uczciwości.

Używaj semaforów tylko wtedy, gdy potrzebujesz semantyki zwalniania prawa własności.

Myślę, że powinieneś spróbować:

Podczas inicjalizacji semafora:

Semaphore semaphore = new Semaphore(1, true);

I w twoim Runnable Implementation

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

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

Błędem w oryginalnym poście jest wywołanie acquiringu () ustawione wewnątrz pętli try. Oto poprawne podejście do używania semafora „binarnego” (Mutex):

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

Aby upewnić się, że a Semaphorejest binarny, musisz tylko upewnić się, że podczas tworzenia semafora podano liczbę zezwoleń jako 1. W Javadocs mieć nieco więcej wyjaśnień.

Blokada każdego obiektu różni się nieco od projektu Mutex / Semaphore. Na przykład nie ma sposobu, aby poprawnie zaimplementować przechodzenie przez połączone węzły ze zwolnieniem blokady poprzedniego węzła i przechwyceniem następnego. Ale z muteksem łatwo jest zaimplementować:

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

Obecnie nie ma takiej klasy w programie java.util.concurrent, ale implementację Mutext można znaleźć tutaj Mutex.java . Jeśli chodzi o biblioteki standardowe, Semaphore zapewnia wszystkie te funkcje i wiele więcej.