java并发：轻量级非阻塞信号量？

Question

我遇到一种情况，我想执行一次回调。为了便于论证，我们假设它看起来像这样：

final X once = new X(1);
Runnable r = new Runnable() {
    @Override public void run() {
        if (once.use())
           doSomething();
    }
}

其中 X 是具有以下行为的并发对象：

• 构造函数：X(int N) -- 分配 N 使用许可

• boolean use()：如果至少有 1 个使用许可，则使用其中一个并返回 true。否则返回 false。此操作对于多个线程来说是原子的。

我知道我可以使用 java.util。 concurrent.Semaphore 为此，但我不需要它的阻塞/等待方面，并且我希望这是一次性使用的东西。

AtomicInteger 看起来不够，除非我做了类似的事情

class NTimeUse {
   final private AtomicInteger count;
   public NTimeUse(int N) { this.count = new AtomicInteger(N); }
   public boolean use() {
       while (true)
       {
          int n = this.count.get();
          if (n == 0)
             return false;
          if (this.count.compareAndSet(n, n-1))
             return true;
       }
   }

，并且我对 while 循环感到恶心。

CountDownLatch 不起作用，因为 countDown() 方法 没有返回值，并且不能使用 getCount() 以原子方式执行。

我应该只使用 Semaphore 还是有更合适的类？

Answer 1

在单个许可的情况下，您可以使用 AtomicBoolean：

final AtomicBoolean once = new AtomicBoolean(true);
Runnable r = new Runnable() {
    @Override public void run() {
        if (once.getAndSet(false))
           doSomething();
    }
}

如果您需要多个许可，请使用 compareAndSet() 解决方案。不用担心循环，getAndIncrement() 在幕后的工作方式相同。

Answer 2

是的。 AtomicInteger 是非阻塞的。您可以使用 getAndDecrement()。

您可以使用类似的方法，

if(counter.getAndDecrement() > 0) {
   // something
} else {
   counter.set(0);
}

只要您在递减和集合之间不调用它二十亿次，这就会起作用。也就是说，您需要有 20 亿个线程在这两个语句之间停止。

同样，您可以使用 AtomicLong 来进行额外的偏执。

Answer 3

// This implements an unfair locking scheme:
while ( mayContinue() ) {
    // acquire the permit and check if it was legally obtained
    if ( counter.decrementAndGet() > 0 )
        return true;
    // return the illegally acquired permit
    counter.incrementAndGet();
}
return false;

如果您发现非法获得许可，则将计数器设置回零，从而在另一个线程释放许可时产生竞争条件。这只适用于最多 2 或 3 个线程的情况。如果您有更多，则需要添加一些其他退避或锁定机制。