Java中有互斥体吗？

Question

java中有互斥对象或者创建互斥对象的方法吗？ 我这么问是因为用 1 个许可证初始化的信号量对象对我没有帮助。 考虑这种情况：

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

上面的代码能确保信号量是二进制的吗？

Answer 1

Java 中的任何对象都可以通过 synchronized 块用作锁。当异常发生时，这也会自动释放锁。

Object someObject = ...;

synchronized (someObject) {
  ...
}

您可以在此处阅读有关此内容的更多信息：内在锁和同步

Answer 2

请参阅此页面：http://www.oracle.com/technetwork/articles /javase/index-140767.html

它有一个稍微不同的模式，这是（我认为）您正在寻找的：

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

在这种用法中，您仅在之后调用 release()成功的acquire()

Answer 3

没有人明确提到这一点，但这种模式通常不适合信号量。原因是任何线程都可以释放信号量，但您通常只想要< em>所有者线程最初锁定以便能够解锁。对于这个用例，在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 源代码中的一个示例，您可以在其中看到此模式的实际应用。

可重入锁还有支持公平性的额外好处。

仅当需要非所有权释放语义时才使用信号量。

Answer 4

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

Answer 5

我认为你应该尝试使用：

虽然信号量初始化：

Semaphore semaphore = new Semaphore(1, true);

并且在你的Runnable Implementing中

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

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

Answer 6

原帖中的错误是在 try 循环内设置了 acquire() 调用。
这是使用“二进制”信号量（互斥体）的正确方法：

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

Answer 7

每个对象的锁与互斥/信号量设计略有不同。
例如，没有办法正确地实现通过释放前一个节点的锁并捕获下一个节点来遍历链接节点。但是使用 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。至于标准库，Semaphore 提供了所有这些功能以及更多功能。

Answer 8

要确保信号量是二进制的，您只需确保在创建信号量时传入的许可数为 1。 Javadocs 有一点更多解释。