Gibt es einen Mutex in Java?

Gibt es ein Mutex-Objekt in Java oder eine Möglichkeit, eines zu erstellen? Ich frage, weil ein Semaphor-Objekt, das mit 1 Erlaubnis initialisiert wurde, mir nicht hilft. Denken Sie an diesen Fall:

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

Wenn beim ersten Erwerb eine Ausnahme auftritt, erhöht die Freigabe im catch-Block die Berechtigungen, und das Semaphor ist kein binäres Semaphor mehr.

Wird der richtige Weg sein?

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

Wird der obige Code sicherstellen, dass das Semaphor binär ist?

Siehe diese Seite: http://www.oracle.com/technetwork/articles/javase/index-140767.html

Es hat ein etwas anderes Muster, das (glaube ich) das ist, wonach Sie suchen:

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

In dieser Verwendung rufen Sie erst release()nach einem erfolgreichen anacquire()

Jedes Objekt in Java kann mithilfe eines synchronizedBlocks als Sperre verwendet werden . Dadurch wird auch automatisch die Sperre aufgehoben, wenn eine Ausnahme auftritt.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Weitere Informationen hierzu finden Sie hier: Eigensperren und Synchronisierung

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

Niemand hat dies klar erwähnt, aber diese Art von Muster ist normalerweise nicht für Semaphoren geeignet. Der Grund dafür ist , dass jeder Thread eine Semaphore freigeben kann, aber Sie wollen in der Regel nur den Besitzer Thread , der ursprünglich zu entsperren können gesperrt werden . Für diesen Anwendungsfall verwenden wir in Java normalerweise ReentrantLocks, die wie folgt erstellt werden können:

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

private final Lock lock = new ReentrantLock(true);

Und das übliche Design-Verwendungsmuster ist:

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

Hier ist ein Beispiel im Java-Quellcode, in dem Sie dieses Muster in Aktion sehen können.

Wiedereintrittsschlösser haben den zusätzlichen Vorteil, dass sie die Fairness unterstützen.

Verwenden Sie Semaphoren nur, wenn Sie eine Semantik ohne Eigentumsfreigabe benötigen.

Ich denke, Sie sollten versuchen mit:

Während der Semaphor-Initialisierung:

Semaphore semaphore = new Semaphore(1, true);

Und in deinem Runnable Implementation

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

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

Ein Fehler im ursprünglichen Beitrag ist der Aufruf von purchase (), der in der try-Schleife festgelegt wurde. Hier ist ein korrekter Ansatz zur Verwendung des "binären" Semaphors (Mutex):

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

Um sicherzustellen, dass a Semaphorebinär ist, müssen Sie beim Erstellen des Semaphors nur sicherstellen, dass Sie die Anzahl der Genehmigungen als 1 übergeben. Die Javadocs haben etwas mehr Erklärung.

Die Sperre jedes Objekts unterscheidet sich kaum vom Mutex / Semaphore-Design. Zum Beispiel gibt es keine Möglichkeit, das Durchlaufen verknüpfter Knoten korrekt zu implementieren, indem die Sperre des vorherigen Knotens aufgehoben und der nächste erfasst wird. Mit Mutex ist es jedoch einfach zu implementieren:

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

Derzeit gibt es keine solche Klasse java.util.concurrent, aber die Mutext-Implementierung finden Sie hier Mutex.java . In Bezug auf Standardbibliotheken bietet Semaphore all diese Funktionen und vieles mehr.