如何在Java中实现并发循环收报机（计数器）？

Question

我想用Java实现一个循环计数器。 每个请求的计数器应该（自动）递增，并且在达到上限时应该翻转到 0。

实现此目的的最佳方法是什么？是否有任何现有的实现？

Answer 1

使用 Java 8

public class CyclicCounter {

    private final int maxVal;
    private final AtomicInteger counter = new AtomicInteger(0);

    public CyclicCounter(int maxVal) {
      this.maxVal = maxVal;
    }

    public long incrementAndGet() {
        return counter.accumulateAndGet(1, (index, inc) -> (++index >= maxVal ? 0 : index));
    }

}

Answer 2

如果您担心使用 CAS 或同步的争用，那么您可以考虑更复杂的东西，例如建议的 JSR 166e LongAdder (来源，javadoc ）。

这是一个简单的计数器，多线程访问争用很少。您可以将其包装起来以公开（当前值 mod 最大值）。也就是说，根本不存储包装的值。

Answer 3

如果您使用模数运算符，则只需递增并返回模数即可。不幸的是，模数运算符很昂贵，因此我鼓励使用性能很重要的其他解决方案。

public class Count {
    private final AtomicLong counter = new AtomicLong();
    private static final long MAX_VALUE = 500;
    public long getCount() {
        return counter.get() % MAX_VALUE;
    }
    public long incrementAndGet(){
        return counter.incrementAndGet() % MAX_VALUE;

    }
}

您还必须解决 Long.MAX_VALUE 情况。

Answer 4

我个人认为 AtomicInteger 解决方案有点难看，因为它引入了竞争条件，这意味着您的更新尝试可能“失败”并且必须重复（通过在 while 循环内迭代），从而缩短更新时间与在关键部分内执行整个操作相比，确定性较差。

编写自己的计数器非常简单，我推荐这种方法。从面向对象的角度来看，它也更好，因为它只公开允许您执行的操作。

public class Counter {
  private final int max;
  private int count;

  public Counter(int max) {
    if (max < 1) { throw new IllegalArgumentException(); }

    this.max = max;
  }

  public synchronized int getCount() {
    return count;
  }

  public synchronized int increment() {
    count = (count + 1) % max;
    return count;
  }
}

编辑

我认为 while 循环解决方案的另一个问题是，如果有大量线程尝试更新计数器，您最终可能会遇到这样的情况：有多个活动线程在旋转并尝试更新计数器柜台。鉴于只有 1 个线程会成功，所有其他线程都会失败，导致它们迭代并浪费 CPU 周期。

Answer 5

您可以使用 java.lang. util.concurrent.atomic.AtomicInteger 类以原子方式递增。 至于设置上限并回滚到0，您需要在外部执行此操作...也许将所有这些封装在您自己的包装类中。

实际上，它看来您可以使用 compareAndSet 检查上限，然后翻转到 0。

Answer 6

我必须为自定义 Akka 路由逻辑创建一个类似的循环自动收报机，该逻辑必须与默认的不同，以避免网络开销，因为我的逻辑只是选择下一个路由。

注意：从建议的 Java 8 实现中复制：

import akka.routing.Routee;
import akka.routing.RoutingLogic;
import scala.collection.immutable.IndexedSeq;

import java.util.concurrent.atomic.AtomicInteger;

public class CircularRoutingLogic implements RoutingLogic {

  final AtomicInteger cycler = new AtomicInteger();

  @Override
  public Routee select(Object message, IndexedSeq<Routee> routees) {
    final int size = routees.size();
    return size == 0 ? null : routees.apply(cycler.getAndUpdate(index -> ++index < size ? index : 0));
  }
}

Answer 7

对于由多个线程并行递增的高强度循环计数器，我建议使用 LongAdder（从 java 8 开始，请参阅 Striped64.java 中的核心思想），因为它是与 AtomicLong 相比更具可扩展性。很容易将其适应上述解决方案。

假设get操作在LongAdder中不那么频繁。调用 counter.get 时，对其应用“counter.get % max_number”。是的，模运算很昂贵，但对于这种用例来说并不常见，这应该分摊总性能成本。

但请记住，get 操作是非阻塞的，也不是原子的。

Answer 8

在 AtomicInteger 上实现这样的计数器很容易：

public class CyclicCounter {

    private final int maxVal;
    private final AtomicInteger ai = new AtomicInteger(0);

    public CyclicCounter(int maxVal) {
        this.maxVal = maxVal;
    }

    public int cyclicallyIncrementAndGet() {
        int curVal, newVal;
        do {
          curVal = this.ai.get();
          newVal = (curVal + 1) % this.maxVal;
        } while (!this.ai.compareAndSet(curVal, newVal));
        return newVal;
    }

}