AtomicInteger in Concurrent Programming

AtomicInteger is a Java class that enables concurrent access to an underlying integer value. Understanding the practical applications of AtomicInteger is crucial for optimizing concurrency in multi-threaded environments.

Typical Use Cases

AtomicInteger serves two primary purposes:

• Atomic Counter: It can be utilized as a shared counter that can be incremented or decremented concurrently by multiple threads. This is useful in scenarios where an accurate count of events is required, such as tracking the number of requests served.
• Compare-and-Swap Primitive: AtomicInteger supports compare-and-swap operations (compareAndSet()) which allow non-blocking algorithm implementation. In non-blocking algorithms, data is accessed without acquiring locks, reducing the potential for deadlocks and increasing concurrency.

Example of Compare-and-Swap

Brian Göetz's "Java Concurrency In Practice" provides an example of using AtomicInteger for non-blocking random number generation:

public class AtomicPseudoRandom extends PseudoRandom {
    private AtomicInteger seed;
    ...

    public int nextInt(int n) {
        while (true) {
            int s = seed.get();
            int nextSeed = calculateNext(s);
            if (seed.compareAndSet(s, nextSeed)) {
                ...
            }
        }
    }
}

In this example, the seed value is atomically updated using compare-and-swap. The calculation to obtain the next seed is performed without blocking, ensuring that multiple threads can generate random numbers concurrently.