What are atomic data types and what are they used…

Atomic data types are classes from the java.util.concurrent.atomic package that provide primitive types and object references with atomic (indivisible) operations. They are used for safe manipulation of mutable variables in a multithreaded environment without explicit locking (e.g., using synchronized).

Key features:

Atomicity: Guarantee that an operation on a variable is completed entirely or not at all, preventing race conditions.
Non-blocking: Most operations are implemented using low-level Compare-And-Swap (CAS) instructions, which do not block threads.
Performance: In high contention scenarios, they can be more efficient than locks.
Volatile-like memory effects: They have visibility properties similar to the volatile keyword.

Examples of popular atomic types:

AtomicBoolean
AtomicInteger
AtomicLong
AtomicReference
AtomicIntegerArray
AtomicLongArray
AtomicReferenceArray

Main operations include:

get(): Get the current value.
set(newValue): Set a new value.
compareAndSet(expect, update): Atomically set the value to update if the current value equals expect.
getAndIncrement(): Atomically increment the value by 1 and return the previous value.
incrementAndGet(): Atomically increment the value by 1 and return the new value.

The need for atomic types arises when thread-safe operations on single variables are required without complicating the code with explicit locks or risking deadlocks.

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {

    public static void main(String[] args) throws InterruptedException {
        AtomicInteger counter = new AtomicInteger(0); // Using atomic type

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet(); // Atomic increment
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final counter value: " + counter.get()); // Result will be 2000
    }
}

What are atomic data types and what are they used for?