feat: implement thread-safe counter using AtomicInteger vs volatile

WHAT was added:
- A class `VolatileCounter2` demonstrating difference between `volatile` and `AtomicInteger`.
- Two worker threads increment a shared counter 1000 times each.
- Shows how `AtomicInteger.incrementAndGet()` ensures atomicity and prevents lost updates.
- Prints final counter value after both threads complete.

WHY this matters:
- `volatile` only guarantees visibility (all threads see latest value),
  but it does not make compound operations (like `counter++`) atomic.
- With plain `volatile`, increments can be lost under race conditions.
- `AtomicInteger` provides atomic methods (`incrementAndGet`, `getAndAdd`, etc.)
  using low-level Compare-And-Swap (CAS), ensuring correctness without locks.
- This example highlights when to use `volatile` vs when to prefer `AtomicInteger`.

HOW it works:
1. Shared `AtomicInteger counter` initialized to 0.
2. Two threads concurrently call `vc2.increment()` 1000 times each.
3. `incrementAndGet()` ensures thread-safe increments.
4. After both threads join, final result is `2000` (no lost updates).
5. Contrast: with plain `volatile int counter`, result could be less than 2000 due to race conditions.

Key Concepts:
- Visibility vs atomicity: `volatile` ensures visibility, `AtomicInteger` ensures both visibility + atomicity.
- CAS operation: retries until update succeeds (non-blocking).
- Lightweight alternative to `synchronized` or `ReentrantLock`.

REAL-LIFE APPLICATIONS:
- Web servers → counting number of requests served in real time safely across multiple threads.
- Rate limiting → tracking API calls per user without race conditions.
- Monitoring systems → counting events/logs without locking overhead.
- Thread-safe statistics → updating counters in analytics pipelines.
- Producer-consumer systems → maintaining counters for produced vs consumed messages.

LIMITATIONS:
- `AtomicInteger` works for simple numeric counters.
- For more complex atomic updates (multiple variables), use locks or `AtomicReference`.
- Busy CAS retry loops may cause performance overhead under very high contention.

KEYWORDS:
volatile atomic integer concurrency race-condition CAS compare-and-swap thread-safe counter.

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

Author: Someshdiwan

Section19MultiThreading/Volatile and Atomic/src/VolatileCounter2.java

@@ -0,0 +1,67 @@
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class VolatileCounter2 {
+    //private int counter = 0;
+    //private volatile int counter = 0;
+
+    private AtomicInteger counter = new AtomicInteger(0);
+    //Thread safe. ek baar mai bas ek thread kaam karega. u also use synchronization and lock.
+
+    public void increament() {
+        //counter++;
+
+        int i = counter.incrementAndGet();
+    }
+
+    public int getCounter() {
+        //return counter;
+
+        return counter.get();
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        VolatileCounter2 vc2 = new VolatileCounter2();
+
+        Thread t3 = new Thread(() -> {
+            for(int i=0; i<1000; i++) {
+                vc2.increament();
+            }
+        });
+
+        Thread t4 = new Thread(() -> {
+            for(int i=0; i<1000; i++) {
+                vc2.increament();
+            }
+        });
+
+        t3.start();
+        t4.start();
+
+        t3.join();
+        t4.join();
+
+        System.out.println(vc2.getCounter());
+    }
+}
+
+/*
+===========================
+ volatile vs AtomicInteger
+===========================
+
+1. volatile int counter = 0;
+   - Threads ko latest value dikhegi.
+   - Lekin counter++ is NOT atomic (read + add + write).
+   - Example: Thread A and B dono read karte hain same old value,
+     dono increment karte hain -> ek update lost ho jaata hai.
+
+2. AtomicInteger counter = new AtomicInteger(0);
+   - Methods like incrementAndGet(), getAndAdd() are atomic.
+   - Internal implementation uses CAS (Compare-And-Swap).
+   - No lost updates, thread-safe without explicit locks.
+
+3. Alternative:
+   - synchronized methods ya ReentrantLock use kar sakte ho,
+     lekin AtomicInteger zyada lightweight aur efficient hota hai
+     simple counters ke liye.
+*/