Java中是否有Mutex？

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 / Semaphore设计几乎没有什么不同。例如，没有办法通过释放前一个节点的锁并捕获下一个的锁来正确实现遍历链接的节点。但是使用互斥锁很容易实现：

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，但是您可以在Mutex.java中找到Mutext实现。至于标准库，Semaphore提供了所有这些功能以及更多其他功能。