作为一个操作线程访问两个 AtomicInteger 是否安全？

Question

在 Brian Goetz 的Java Concurrency in Practice中有一个例子如下：

public class NumberRange {
  // INVARIANT: lower <= upper
  private final AtomicInteger lower = new AtomicInteger(0);
  private final AtomicInteger upper = new AtomicInteger(0);

  public void setLower(int i) {
    // Warning -- unsafe check-then-act
    if (i > upper.get())
    throw new IllegalArgumentException(
    "can't set lower to " + i + " > upper");
    lower.set(i);
  }

  public void setUpper(int i) {
    // Warning -- unsafe check-then-act
    if (i < lower.get())
      throw new IllegalArgumentException(
      "can't set upper to " + i + " < lower");
    upper.set(i);
  }

  public boolean isInRange(int i) {
    return (i >= lower.get() && i <= upper.get());
  }
}

我了解上述代码容易出现竞争条件。

然后他解释如下：

像这样的多变量不变量会产生原子性要求：必须在单个原子操作中获取或更新相关变量。您不能更新一个、释放并重新获取锁，然后再更新其他的，因为这可能涉及在释放锁时使对象处于无效状态。

我从这一段中了解到，如果我们将setUpper 和setLower 函数设为synchronized，那么也会出现对象可能达到无效状态的情况。但是，我认为如果两个函数都是同步的，那么只有一个线程可以执行其中一个函数，并且每个函数都对不变量进行必要的检查。我们怎么能处于无效状态。任何人都可以举例说明。我在这里错过了什么？

如果我理解正确，那么这行的意义是什么：

您不能更新一个、释放并重新获取锁，然后再更新其他的，因为这可能涉及在释放锁时使对象处于无效状态。

Answer 1

来自“Java 并发实践”一书：

NumberRange 可以通过使用锁定来保持其线程安全 不变量，例如用一个共同的锁保护下部和上部。它 还必须避免发布上下限以防止客户 颠覆它的不变量。

这意味着下面的代码是线程安全的：

@ThreadSafe
public class NumberRange {

    @GuardedBy("this") private int lower, upper;

    public synchronized void setLower(int i) {
        if (i > upper) {
            throw new IllegalArgumentException("can't set lower to " + i + " > upper");
        }
        lower = i;
    }

    public synchronized void setUpper(int i) {
        if (i < lower) {
            throw new IllegalArgumentException("can't set upper to " + i + " < lower");
        }
        upper = i;
    }

    public synchronized boolean isInRange(int i) {
        return (i >= lower && i <= upper);
    }
}

在这种情况下，NumberRange 提供自己的锁定以确保复合操作是原子的。