What is the difference between LongAdder and AtomicInteger?

AtomicInteger gives you one integer value that can be updated atomically.

LongAdder is designed for high-throughput counters. Instead of forcing every thread to update one exact shared number, it spreads updates across multiple internal counters and adds them up when you ask for the total.

Imagine 100 threads all incrementing the same request counter:

counter.incrementAndGet();

With AtomicInteger, every thread is trying to update the same single memory location. The operation is thread-safe, but that one location can become a hotspot.

AtomicInteger commonly uses compare-and-set (CAS) style updates. The idea is:

read current value
calculate new value
try to update only if value has not changed

If another thread changed the value first, your update has to retry. With a few threads, this is usually fine. With many threads all hammering the same counter, retries can become expensive.

LongAdder reduces the pressure on one shared variable. Instead of one crowded checkout line, it creates multiple checkout lines.

This is why LongAdder is a great fit for metrics, request counts, hit counters, and frequency maps.

LongAdder is not simply “better AtomicInteger.” It makes a tradeoff.

The most important point: LongAdder.sum() is not an atomic snapshot while other threads are still updating it. For statistics and monitoring, that is usually fine. For sequence numbers, IDs, or exact coordination, it is not fine.

• You need an exact value immediately after each update.
• You are generating sequence numbers.
• You need compare-and-set logic.
• The value participates in coordination or control flow.
• Contention is low and simplicity matters.

AtomicInteger sequence = new AtomicInteger(0);

int nextId = sequence.incrementAndGet();

• Many threads increment the same counter.
• You are collecting metrics or statistics, and don't immediately care about the updated value.
• You mostly care about the total when reporting.
• Throughput matters more than a perfectly atomic read.
• You are building a frequency map with ConcurrentHashMap.

ConcurrentHashMap<String, LongAdder> requestCounts =
    new ConcurrentHashMap<>();

public void recordRequest(String endpoint) {
    requestCounts
        .computeIfAbsent(endpoint, key -> new LongAdder())
        .increment();
}

A common mistake is saying:

That is not quite right. LongAdder can be faster for highly contended counters, but it is not the right tool when each read must represent one exact, globally ordered value.

For example, do not use LongAdder for generating unique sequence numbers:

// Bad idea for unique IDs
LongAdder id = new LongAdder();

id.increment();
long nextId = id.sum();

Multiple threads could increment and read in ways that do not give each thread a clean unique sequence value.