用于有限序列生成的 AtomicInteger

Question

我们如何使用 AtomicInteger 来生成有限的序列，比如序列号必须在 1 到 60 之间。一旦序列达到 60，它必须从 1 重新开始。我写了这段代码，但不太确定这是否是线程安全的？

public int getNextValue()
{
 int v;
 do
 {
   v = val.get();
   if ( v == 60)
   {
    val.set(1);
   }
 }
  while (!val.compareAndSet(v , v + 1));
   return v + 1;
  }

Answer 1

从 Java 8 开始，您可以使用 AtomicInteger.updateAndGet：

return val.updateAndGet(n -> (n >= 60) ? 1 : n + 1);

---

另一种选择是简单地执行...

return val.getAndIncrement() % 60;

...除非您担心超过整数 max-值（2147483647）。如果这是一个问题，您可以查看 getAndIncrement 实现：

public final int getAndIncrement() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return current;
    }
}

您需要将 int next... 行更改为：

int next = (current + 1) % 60;

---

哎呀。这会循环0->59。您需要 1->60，因此将返回值加 1 以获得所需的结果。

Answer 2

您可以使用 Java 8 在一行中完成此操作。

AtomicInteger counter = new AtomicInteger();

public int getNextValue() {
    return counter.updateAndGet(n -> (n >= 60) ? 1 : n + 1);
}

Answer 3

如果您使方法同步，那么只要val没有其他地方访问，它就是线程安全的。然而，该方法有点麻烦，我将其重写如下：

public synchronized int getNextValue() {
    val.compareAndSet(60, 0); // Set to 0 if current value is 60.
    return val.incrementAndGet();
}

这给出了 1 直到 60 返回包含。如果您实际上需要 1 到 59，则将 60 替换为 59。

Answer 4

在这里使用 AtomicInteger 而不仅仅是简单的同步方法有什么特殊原因吗？

像下面这样简单的事情怎么样：

private int val=1;

public synchronized int getNextValue() {
 int v=val;
 val = (val==60) ? 1 : (val+1); 
 return v;
}

Answer 5

不，它不是线程安全的 - 你不应该在循环内调用 set ：

int value, next;
do {
    value = val.get();
    next = (value == 60) ? 1 : (value + 1);
} while (!val.compareAndSet(value, next);
return next;

Answer 6

快速回答，不是线程安全的。测试和设置需要是原子的，除非您使整个方法同步。请注意 val.get() 和 v 的测试不是原子的。如果线程在 v = val.get() 之后产生，您将收到具有相同序列号的两个调用。

另外，如果 CompareAndSet 失败，您永远不会更改值，这将是一个无限循环。

原子整数有一个
getAndIncrement()
称呼。这将为您带来一个干净的返回值。

滚动有点棘手。一种解决方案是修改返回值。像这样：

int v = val.getAndIncrement();
return (v % 60) + 1;

由于每个线程都有 v 的本地副本，我们可以安全地对其进行一些数学计算并返回值。如果出现溢出，就会出现一个症结所在。根据您生成序列号的频率，这可能是也可能不是问题。