Atomic Variables in Java

Atomic variables, in java.util.concurrent.atomic, are classes that hold a single value and update it atomically, as one indivisible step, without locks. AtomicInteger.incrementAndGet() does the whole "read, add one, write" safely even when many threads call it at once, which a plain count++ can't. The main classes are AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference and the high-throughput LongAdder. In this lesson, you will learn their methods and when to use each.

The Main Atomic Classes

Methods of AtomicInteger

Example: Counters and Updates

Let's see an example where four threads update shared atomic values.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.LongAdder;
 
public class Atomics {
    public static void main(String[] args) {
        AtomicInteger visits = new AtomicInteger();
        AtomicInteger highest = new AtomicInteger();
        LongAdder clicks = new LongAdder();
 
        try (ExecutorService pool = Executors.newFixedThreadPool(4)) {
            for (int t = 0; t < 4; t++) {
                int base = t * 10;
                pool.submit(() -> {
                    for (int i = 0; i < 25_000; i++) {
                        visits.incrementAndGet();
                        clicks.increment();
                    }
                    highest.accumulateAndGet(base + 7, Math::max);
                });
            }
        }
        System.out.println("Visits: " + visits.get());
        System.out.println("Clicks: " + clicks.sum());
        System.out.println("Highest score: " + highest.get());
 
        AtomicReference<String> leader = new AtomicReference<>("Navika");
        boolean changed = leader.compareAndSet("Navika", "Srihitha");
        boolean changedAgain = leader.compareAndSet("Navika", "Advitha");
        System.out.println("Leader: " + leader.get()
            + " (changes: " + changed + ", " + changedAgain + ")");
    }
}

Visits: 100000
Clicks: 100000
Highest score: 37
Leader: Srihitha (changes: true, false)

Explanation: Four threads each add 25,000 to visits and clicks, and no update is lost: both reach 100,000. accumulateAndGet(x, Math::max) safely keeps the largest value any thread offered (the threads offered 7, 17, 27 and 37). compareAndSet("Navika", "Srihitha") succeeds because the leader really was Navika; the second call fails because the leader is no longer Navika, so Advitha's change is refused.

AtomicLong vs LongAdder

Common Mistakes

Calling get() then set(get() + 1). That's two steps again; use incrementAndGet().

Using LongAdder where you need compareAndSet or an exact snapshot. Use AtomicLong.

Expecting atomics to coordinate several variables. Each atomic covers only itself.

Interview Corner

Practice

1. Easy: Replace a synchronized ID generator with an AtomicLong and generate ten IDs from three threads.
2. Harder: Keep a "best score and its player" pair in an AtomicReference of a record, and update it from several threads with updateAndGet.

Key Takeaways