Atomicity in Java

In Java, atomicity is often achieved using classes from the java.util.concurrent.atomic package, such as AtomicInteger, AtomicLong, AtomicBoolean, and AtomicReference. These classes provide thread-safe operations on single variables without requiring explicit synchronization or locks.

Example of Atomicity with AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger counter = new AtomicInteger(0);
    public void incrementCounter() {
        counter.incrementAndGet(); // Atomically increments the counter
    }

    public int getCounter() {
        return counter.get(); // Retrieves the current value
    }

    public static void main(String[] args) {
        AtomicExample example = new AtomicExample();
        for (int i = 0; i < 100; i++) {
            new Thread(example::incrementCounter).start();
        }

        // Add delay to ensure all threads complete
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
                e.printStackTrace();
       }
        System.out.println("Final Counter Value: " + example.getCounter());
    }
}

In this example, the incrementAndGet() method ensures that the counter is updated atomically, preventing race conditions even when accessed by multiple threads.

Why Atomicity Matters

Operations on regular primitives like int or long are not atomic. For example, the increment operation (counter++) involves three steps: reading the value, incrementing it, and writing it back. In a multithreaded environment, this can lead to race conditions where multiple threads interfere with each other, resulting in inconsistent or incorrect values.

Comparison: Regular Primitives vs. Atomic Variables

public class NonAtomicExample {
    private int counter = 0;
    public synchronized void incrementCounter() {
        counter++; // Not atomic without synchronization
    }

    public int getCounter() {
        return counter;
    }

    public static void main(String[] args) {
        NonAtomicExample example = new NonAtomicExample();
        for (int i = 0; i < 100; i++) {
        new Thread(example::incrementCounter).start();
    }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final Counter Value: " + example.getCounter());
    }
}