Javaにミューテックスはありますか？

JavaのMutexオブジェクトまたはそれを作成する方法はありますか？1つの許可で初期化されたSemaphoreオブジェクトが役に立たないので、私は尋ねています。このケースを考えてみましょう：

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

最初の取得で例外が発生した場合、catchブロックでの解放により許可が増加し、セマフォはバイナリセマフォではなくなります。

正しい方法はありますか？

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

上記のコードはセマフォがバイナリであることを保証しますか？

このページを参照してください：http : //www.oracle.com/technetwork/articles/javase/index-140767.html

それはあなたが探しているもの（私は思う）であるわずかに異なるパターンを持っています：

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

この使用法ではrelease()、成功した後にのみ呼び出しますacquire()

Javaのすべてのオブジェクトは、synchronizedブロックを使用してロックとして使用できます。これにより、例外が発生したときにロックが自動的に解放されます。

Object someObject = ...;

synchronized (someObject) {
  ...
}

詳細については、こちらをご覧ください：組み込みロックと同期

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

誰もこれについて明確に述べたことはありませんが、この種のパターンは通常、セマフォには適していません。その理由は、どのスレッドもセマフォを解放できるからです。通常は、最初にロックされていた所有者のスレッドだけがロックを解除できるようにする必要があります。この使用例では、Javaでは通常、次のように作成できるReentrantLocksを使用します。

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

private final Lock lock = new ReentrantLock(true);

そして、使用の通常の設計パターンは次のとおりです。

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

ここではあなたがアクションでこのパターンを見ることができますJavaのソースコードの例です。

再入可能ロックには、公平性をサポートするという追加の利点があります。

非所有権解放のセマンティクスが必要な場合にのみ、セマフォを使用してください。

私はあなたが試してみるべきだと思います：

セマフォの初期化中：

Semaphore semaphore = new Semaphore(1, true);

そしてあなたの Runnable Implementation

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

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

元の投稿の間違いは、tryループ内にセットされたacquire（）呼び出しです。以下は、「バイナリ」セマフォ（Mutex）を使用するための正しいアプローチです。

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

a Semaphoreがバイナリであることを確認するには、セマフォを作成するときに、許可の数を1として渡す必要があります。Javadocは、もう少し説明があります。

各オブジェクトのロックは、Mutex /セマフォの設計と少し異なります。たとえば、前のノードのロックを解除して次のノードをキャプチャすることで、リンクされたノードのトラバースを正しく実装する方法はありません。しかし、ミューテックスを使用すると、簡単に実装できます。

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

現在、中にはそのようなクラスがありませんjava.util.concurrentが、あなたはここでMutextの実装を見つけることができMutex.javaを。標準ライブラリに関しては、セマフォはこのすべての機能を提供します。