feat: add AtomicInteger example to demonstrate thread-safe counter

WHAT was added:
- Implemented `AtomicExample` with two threads incrementing a shared `AtomicInteger`.
- Each thread performs 1000 increments; final result is guaranteed to be 2000.
- Demonstrates atomic operations (`incrementAndGet`) vs. non-atomic counter++.

WHY this matters:
- In multithreaded environments, `counter++` is not atomic (read + add + write).
- Using a plain `volatile int` only ensures visibility, not atomicity → lost updates.
- `AtomicInteger` provides lock-free, thread-safe operations using Compare-And-Swap (CAS).
- This ensures correctness without the overhead of `synchronized`.

HOW it works:
1. Create an `AtomicInteger counter = new AtomicInteger(0)`.
2. Start two threads, each incrementing counter 1000 times.
3. `incrementAndGet()` ensures each increment is atomic.
4. Final result is always 2000, unlike volatile int (unpredictable) or synchronized (heavier).

REAL-LIFE APPLICATIONS:
- Web servers → counting active users or requests safely across multiple threads.
- Banking systems → tracking transactions without race conditions.
- Metrics/Monitoring → maintaining counters for errors, API hits, or performance stats.
- Concurrent data structures (e.g., ConcurrentHashMap) internally use atomic variables for efficiency.
- Gaming/Simulation engines → shared score counters or physics computations.

ALTERNATIVES & COMPARISON:
- volatile int → ensures visibility but not atomicity → unsafe for counter.
- synchronized → ensures atomicity & visibility but adds lock contention (slower).
- AtomicInteger → ensures atomicity & visibility, lock-free (faster under low/moderate contention).

KEYWORDS:
atomicity, CAS (Compare-And-Swap), race condition prevention, lock-free concurrency, volatile vs synchronized vs AtomicInteger.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section19MultiThreading/Volatile and Atomic/src/AtomicExample.java

@@ -1,2 +1,49 @@
+import java.util.concurrent.atomic.AtomicInteger;
+
 public class AtomicExample {
+    public static void main(String[] args) throws InterruptedException {
+        // AtomicInteger: ek atomic counter jo thread-safe hai
+        AtomicInteger counter = new AtomicInteger(0);
+
+        // Thread 1: increments 1000 times
+        Thread t1 = new Thread(() -> {
+            for (int i = 0; i < 1000; i++) {
+                counter.incrementAndGet(); // atomic increment
+            }
+        });
+
+        // Thread 2: increments 1000 times
+        Thread t2 = new Thread(() -> {
+            for (int i = 0; i < 1000; i++) {
+                counter.incrementAndGet(); // atomic increment
+            }
+        });
+
+        t1.start();
+        t2.start();
+
+        t1.join();
+        t2.join();
+
+        //Final result always 2000 (race condition nahi hoga)
+        System.out.println("Final counter value: " + counter.get());
+    }
 }
+
+/*
+Why AtomicInteger?
+- Agar simple int + volatile use karte:
+    counter++;
+    Yeh do steps hai: read -> add -> write
+    Multiple threads me lost updates ho jaati hai (result unpredictable).
+
+- AtomicInteger methods:
+    - incrementAndGet()   -> ++counter (atomic)
+    - getAndIncrement()   -> counter++ (atomic)
+    - addAndGet(n)        -> counter += n (atomic)
+    - get()               -> safe read
+
+- Internally, AtomicInteger CAS (Compare-And-Swap) ka use karta hai.
+  Matlab ek hi thread successful hota hai update karne me, 
+  baaki retry karte hain.
+*/