private long count = 0;
public synchronized void increment() {
    count++;
}

AtomicLong counter = new AtomicLong();
public void increment() {
    counter.incrementAndGet();
}

transient volatile Cell[] cells;
transient volatile long base;

@sun.misc.Contended static final class Cell {
    volatile long value;
    // ...
}

public class ApiMonitor {
    private final LongAdder successCount = new LongAdder();
    private final LongAdder errorCount = new LongAdder();
    private final LongAdder totalLatency = new LongAdder();
    public void recordSuccess(long latency) {
        successCount.increment();
        totalLatency.add(latency);
    }
    public void recordError() {
        errorCount.increment();
    }
    public MonitoringData getStats() {
        return new MonitoringData(
            successCount.sum(),
            errorCount.sum(),
            totalLatency.sum() / (double) successCount.sum()
        );
    }
}

public class RateLimiter {
    private final LongAdder requestCount = new LongAdder();
    private final int maxRequests;
    public RateLimiter(int maxRequests) {
        this.maxRequests = maxRequests;
    }
    public boolean tryAcquire() {
        if(requestCount.sum() < maxRequests) {
            requestCount.increment();
            return true;
        }
        return false;
    }
    public void reset() {
        requestCount.reset();
    }
}

static final int getProbe() {
    return UNSAFE.getInt(Thread.currentThread(), PROBE);
}

if (cs == null || (m = cs.length - 1) < 0)
    init();

public long sum() {
    Cell[] cs = cells;
    long sum = base;
    if (cs != null) {
        for (Cell c : cs)
            if (c != null)
                sum += c.value;
    }
    return sum;
}

// 非精確快照
long snapshot = adder.sum(); 
// 精確快照需要暫停所有線程（不現實）

LongAccumulator accumulator = new LongAccumulator(Long::sum, 0L);