Atomic is a type of variable that performs read, write and update in a single uninterruptible step, ensuring thread-safe operations and preventing race conditions
- It ensures data consistency without using synchronization or locks.
- It improves performance through non-blocking, lock-free operations.
- Simplify thread-safe programming for common operations like increment and compare-and-set.
Example: AtomicInteger in Multi-threading
import java.util.concurrent.atomic.AtomicInteger;
class Counter extends Thread {
AtomicInteger count = new AtomicInteger();
public void run() {
int max = 100_000_000;
for (int i = 0; i < max; i++) {
count.incrementAndGet();
}
}
}
public class AtomicCounter {
public static void main(String[] args) throws InterruptedException {
Counter first = new Counter();
Counter second = new Counter();
first.start();
second.start();
first.join();
second.join();
// ❗ Problem: each thread has its own counter
System.out.println(first.count.get() + second.count.get());
}
}
Output
200000000
Explanation:
- AtomicInteger ensures increments happen atomically (no interference between threads).
- addAndGet(1) replaces count++, making it thread-safe.
- This removes race conditions and guarantees the correct final count even with multiple threads.
Example: Without Atomic Variables (Unsafe Code)
class Counter implements Runnable {
int count = 0;
public void run() {
int max = 100_000_000;
for (int i = 0; i < max; i++) {
count++;
}
}
}
public class UnSafeCounter {
public static void main(String[] args) throws InterruptedException {
Counter c = new Counter();
Thread first = new Thread(c, "First");
Thread second = new Thread(c, "Second");
first.start();
second.start();
first.join();
second.join();
System.out.println(c.count);
}
}
Output
100238993
Explanation:
- Both threads (first and second) update the same count variable without synchronization.
- Since count++ is not atomic (it involves read, increment, write), multiple threads may interleave, causing incorrect results.
- You expect count = 2 * max, but the final value will usually be less because increments get lost.
Types of Atomic Variables in Java
Below are some commonly used atomic variable types in Java.
1. AtomicInteger
AtomicInteger provides atomic operations (increment, decrement, add, etc.) on integer values without synchronization.
import java.util.concurrent.atomic.AtomicInteger;
public class GFG{
public static void main(String[] args){
AtomicInteger count = new AtomicInteger(5);
count.incrementAndGet(); // 6
count.addAndGet(3); // 9
System.out.println("Final Value: " + count.get());
}
}
Output
Final Value: 9
2. AtomicLong
AtomicLong supports atomic operations on long values for thread-safe numeric computations.
import java.util.concurrent.atomic.AtomicLong;
public class GFG{
public static void main(String[] args) {
AtomicLong counter = new AtomicLong(100);
// adds 50, returns old value
counter.getAndAdd(50);
System.out.println("Updated Value: " + counter.get());
}
}
Output
Updated Value: 150
3. AtomicBoolean
AtomicBoolean represents a boolean value that can be atomically updated for safe flag-based operations.
import java.util.concurrent.atomic.AtomicBoolean;
public class GFG {
private static AtomicBoolean flag
= new AtomicBoolean(false);
public static void main(String[] args)
{
if (flag.compareAndSet(false, true)) {
System.out.println(
"Operation performed only once!");
}
else {
System.out.println("Already performed!");
}
}
}
Output
Operation performed only once!
4. AtomicReference
AtomicReference allows atomic read and write of object references, useful for non-primitive data.
import java.util.concurrent.atomic.AtomicReference;
public class GFG{
public static void main(String[] args){
AtomicReference<String> message
= new AtomicReference<>("Hello");
message.compareAndSet("Hello",
"Hi, from AtomicReference!");
System.out.println("Current Message: "
+ message.get());
}
}
Output
Current Message: Hi, from AtomicReference!
5. AtomicIntegerArray
AtomicIntegerArray enables atomic operations on elements of an integer array for thread-safe updates.
import java.util.concurrent.atomic.AtomicIntegerArray;
public class GFG {
public static void main(String[] args)
{
AtomicIntegerArray numbers
= new AtomicIntegerArray(new int[] { 1, 2, 3 });
numbers.incrementAndGet(
1); // Increment element at index 1
System.out.println("Array after update: "
+ numbers);
System.out.println("Value at index 1: "
+ numbers.get(1));
}
}
Output
Array after update: [1, 3, 3] Value at index 1: 3
Commonly used methods in Atomic classes
| Method | Description |
|---|---|
| get() | Returns the current value. |
| set(value) | Sets the value to the given value. |
| getAndSet(value) | Atomically sets a new value and returns the old one. |
| incrementAndGet() | Increments the value by one and returns the updated value. |
| getAndIncrement() | Increments the value by one and returns the previous value. |
| decrementAndGet() | Decrements the value by one and returns the updated value. |
| addAndGet(delta) | Adds the specified value and returns the updated result. |
| getAndAdd(delta) | Adds the specified value and returns the previous result. |
| compareAndSet(expected, update) | Atomically updates the value only if it equals the expected value. |
| lazySet(value) | Eventually sets the value (may be delayed for performance). |