竞争条件是否有更好的 AtomicInteger 比较功能？

Question

我正在尝试为现有类编写一个装饰器，如果没有足够的可用资源，该类会拒绝。这是一个完全没有多线程的代码示例版本：

public interface Handler {
    boolean handleTask(Task myTask); // returns true if successful, false if failure
}

public interface Task {
    int getResources();
    // Among other things
}

public BlockingHandler implements Handler {
    private int occupied;
    private final int limit;

    private final Handler backingHandler;

    BlockingHandler(Handler backingHandler) {
        this.backingHandler = backingHandler;
    }

    @Override
    public boolean handleTask(Task myTask) {
        if(myTask.getResources() + occupied > limit) return false;
        occupied += myTask.getResources();
        return backingHandler.handleTask(myTask);
    }

    // Don't worry about this part, I'm not doing it this way, I just want the code to make sense
    public void notifyResourceRelease(Task finishedTask) {
        if(finishedTask.isDone()) occupied -= myTask.getResources();
    }
}

问题是，这个handleTask 方法可以在多个线程上调用，而且我想要非常快（即避免synchronized）。将occupied 设为volatile 或AtomicInteger 是不够的，因为仍然可能存在竞争条件，例如：

Thread 1: call handleTask
Thread 1: call atomicOccupied.get()
Thread 2: call handleTask
Thread 1: evaluate if condition
Thread 2: call atomicOccupied.get()

不使用synchronized 是否可以做到这一点？例如，是否有一个扩展的AtomicInteger 类具有更强大的compareAndSet？

Answer 1

是否可以在不使用同步的情况下做到这一点？例如，是否存在具有更强大 compareAndSet 的扩展 AtomicInteger 类？

您应该能够在没有 synchronized 块的情况下执行此操作。不，没有更多的扩展 AtomicInteger 类。

如果我了解您的要求，您可以在 while 循环中执行此操作。比如：

final AtomicInteger occupied = new AtomicInteger();
...
int prev;
int numResources = myTask.getResources();
do {
    prev = occupied.get();
    if (numResources + prev > limit) return false;
} while (!occupied.compareAndSet(prev, prev + numResources));

如果可能，此循环将旋转更新占用。如果达到限制，它将返回 false。您需要旋转，因为如果其他线程在您获得前一个值并且您去调整值之间更新了占用计数，那么您将需要循环并再次获取占用计数。这是典型的模式。

---

另外，您需要使用AtomicInteger 而不是volatile，因为您使用的是compareAndSet。有关详细信息，请参阅此问题：

What is the difference between using a volatile primitive over atomic variables?