java - 是否有更好的 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 的情况下做到这一点？例如，是否有具有更强大的 compareAndSet 的扩展 AtomicInteger 类？

Answer 1

Is it possible to do this without using synchronized? Is there, for instance, an extended AtomicInteger class with a more powerful compareAndSet?

你应该能够在没有 synchronized block 的情况下做到这一点。不，没有更多的扩展 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?