Java中有互斥锁吗？

Question

在 java 中是否有 Mutex 对象或创建方法？ 我问是因为用 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) {
  ...
}

您可以在此处阅读更多信息：Intrinsic Locks and Synchronization

Answer 2

查看此页面：http://www.oracle.com/technetwork/articles/javase/index-140767.html

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

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

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

Answer 3

没有人明确提到这一点，但这种模式通常不适合信号量。原因是任何线程都可以释放信号量，但你通常只想要originally locked to be able to 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();
  }

Here 是 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 Implementation

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

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

Answer 6

原始帖子中的错误是在 try 循环中设置了 acquire() 调用。 这是使用“二进制”信号量 (Mutex) 的正确方法：

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

Answer 7

每个对象的锁都与 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 提供了所有这些功能以及更多功能。

Answer 8

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