.NET 的 ManualResetEvent 和 WaitHandle 的 Java 等效项

Question

我想知道 Java 是否提供了 .NET 的 ManualResetEvent 和 WaitHandle 类的等效项，因为我想编写在给定超时时间内阻塞的代码，除非触发事件。

.NET 类 WaitHandle 和 ManualResetEvent 提供了一个很好的、无麻烦的接口，据我所知，它也是线程安全的，那么 Java 必须提供什么呢？

Answer 1

您是否考虑过使用 wait/notify （相当于 Monitor.Wait 和 Monitor.Pulse）？

您需要进行一些检查，看看您是否确实需要等待（以避免竞争条件），但它应该可以工作。

否则，类似于 CountDownLatch 很可能会做你想做的事。

编辑：我刚刚注意到 CountDownLatch 基本上是“一次性使用” - 据我所知，以后您无法重置计数。您可能需要 Semaphore 相反。像这样使用 tryAcquire 来等待超时：

if (semaphore.tryAquire(5, TimeUnit.SECONDS)) {
   ...
   // Permit was granted before timeout
} else {
   // We timed out while waiting
}

请注意，这与 ManualResetEvent 不同，每次成功调用 tryAcquire 都会减少许可数量- 所以最终他们会再次耗尽。您无法像使用 ManualResetEvent 那样将其永久“设置”。 （这可以与 CountdownLatch 一起使用，但是你无法“重置”它:)

Answer 2

来自：http://www.experts-exchange.com/Programming/ Languages/Java/Q_22076798.html

您好，您可以使用 java.util.concurrent.Semaphore 类实现同步（使用 0 许可）。

http://java.sun. com/j2se/1.5.0/docs/api/java/util/concurrent/Semaphore.html

下面的示例向您展示了如何解决第一个同步问题，其他同步问题将类似：

import java.util.concurrent.Semaphore;

class ScalesCommunication {

   private static Semaphore sem = new Semaphore(0);

   // called by thread 1
   void readLoop() {
      //...

      //after connection established, release semaphore (value incremented by 1)
      sem.release();
   }

   // called by thread 2
   String sendCommand(String command) {

       sem.acquire(); // thread waits here if sem value == 0

       // at this point connection is established
       //...
   }
}

Answer 3

class ManualResetEvent {

  private final Object monitor = new Object();
  private volatile boolean open = false;

  public ManualResetEvent(boolean open) {
    this.open = open;
  }

  public void waitOne() throws InterruptedException {
    synchronized (monitor) {
      while (open==false) {
          monitor.wait();
      }
    }
  }

  public void set() {//open start
    synchronized (monitor) {
      open = true;
      monitor.notifyAll();
    }
  }

  public void reset() {//close stop
    open = false;
  }
}

Answer 4

理论上，上面给出的 ManualResetEvent 类在 Java 5 上是正确的（但不是更早版本）。鉴于 volatile 的错误（或不充分）实现的悠久历史，对我来说，在 reset() 中添加额外的同步块以生成有保证的写入屏障并确保完整的原子性似乎更明智。危险在于，在多处理器 Intel cpu 上，“open”的读取可能会传递“open”的写入。下面给出的更改的优点：它可能不是最佳效率，但它确实具有保证不会出错的巨大优点，而且只需很少的额外成本。

   class ManualResetEvent {
      private final Object monitor = new Object();
      private volatile boolean open = false;

      public ManualResetEvent(boolean open) {
        this.open = open;   }

      public void waitOne() throws InterruptedException {
        synchronized (monitor) {
          while (open==false) {
              monitor.wait();
          }
        }
      }

      public void set() {//open start
        synchronized (monitor) {
          open = true;
          monitor.notifyAll();
        }
      }

      public void reset() {//close stop
        synchronized(monitor) {
           open = false;
        }
      }
   }

感谢原海报。