java - 如何在Java中实现二进制信号量类？

Question

我可以看到如何在 Java 中实现“标准”信号量类。但是，我不知道如何在 Java 中实现二进制信号量类。这样的实现如何运作？我应该什么时候调用唤醒和通知方法来唤醒和停止信号量上的线程？我了解二进制信号量是什么，但我不知道如何编写它们。

编辑注意:意识到我说的是“BINARY”信号量类。我已经完成了标准信号量类，并且我知道它是正确的，因此标准信号量类对我不感兴趣。

Answer 1

我认为您正在谈论互斥锁(或互斥锁)。如果是这样，您可以使用内在锁。 Java 中的这种锁充当互斥体，这意味着最多一个线程可以拥有该锁:

synchronized (lock) { 
    // Access or modify shared state guarded by lock 
}

其中lock是一个模拟对象，仅用于锁定。

<小时/>

编辑:

这是一个为您提供的实现 - 不可重入互斥锁类，它使用值 0 表示解锁状态，使用值 1 表示锁定状态。

class Mutex implements Lock, java.io.Serializable {

    // Our internal helper class
    private static class Sync extends AbstractQueuedSynchronizer {
      // Report whether in locked state
      protected boolean isHeldExclusively() {
        return getState() == 1;
      }

      // Acquire the lock if state is zero
      public boolean tryAcquire(int acquires) {
        assert acquires == 1; // Otherwise unused
        if (compareAndSetState(0, 1)) {
          setExclusiveOwnerThread(Thread.currentThread());
          return true;
        }
        return false;
      }

      // Release the lock by setting state to zero
      protected boolean tryRelease(int releases) {
        assert releases == 1; // Otherwise unused
        if (getState() == 0) throw new IllegalMonitorStateException();
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
      }

      // Provide a Condition
      Condition newCondition() { return new ConditionObject(); }

      // Deserialize properly
      private void readObject(ObjectInputStream s)
          throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
      }
    }

    // The sync object does all the hard work. We just forward to it.
    private final Sync sync = new Sync();

    public void lock()                { sync.acquire(1); }
    public boolean tryLock()          { return sync.tryAcquire(1); }
    public void unlock()              { sync.release(1); }
    public Condition newCondition()   { return sync.newCondition(); }
    public boolean isLocked()         { return sync.isHeldExclusively(); }
    public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
    public void lockInterruptibly() throws InterruptedException {
      sync.acquireInterruptibly(1);
    }
    public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
      return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
  }

如果您需要知道应该在哪里调用 wait() 和 notify()，请查看 sun.misc.Unsafe#park() 。它在 java.util.concurrent.locks 包中使用(AbstractQueuedSynchronizer <- LockSupport <- Unsafe)。

希望这有帮助。