feat: add thread-safe counter using AtomicInteger to ensure atomicity

WHAT was added:
- Implemented `VolatileCounter` class with a shared `AtomicInteger counter`.
- Two threads increment the counter 1000 times each.
- Final value is guaranteed to be 2000 due to atomic increments.
- Demonstrates why `volatile` alone is not sufficient for compound operations like counter++.

WHY this matters:
- Concurrency introduces race conditions when multiple threads update shared variables.
- `volatile` ensures visibility (threads see the latest value) but does not ensure atomicity.
  Example: counter++ = read + add + write (3 steps). These can interleave and cause lost updates.
- `AtomicInteger` provides atomic operations (`incrementAndGet`, `getAndAdd`) using Compare-And-Swap (CAS).
- CAS is lock-free and more efficient than `synchronized` for simple counters.

HOW it works:
1. `counter` is an `AtomicInteger` initialized to 0.
2. Two threads call `vc.increment()` 1000 times each.
3. `incrementAndGet()` ensures the entire increment is atomic.
4. After `join()`, final output is always 2000.
5. Contrast:
   - With plain `volatile int counter`, final result < 2000 (due to lost updates).
   - With `synchronized`, result = 2000 but at the cost of heavier locking.

REAL-LIFE APPLICATIONS:
- Web servers → counting active requests or total hits safely across threads.
- Logging systems → counting error/warning occurrences without locks.
- Metrics & monitoring → real-time counters in Prometheus or similar systems.
- Banking apps → tracking transactions or balance updates safely.
- Producer-consumer queues → keeping track of queue size in multithreaded systems.

LIMITATIONS:
- `AtomicInteger` only solves atomicity for a single variable.
- For multiple related variables (e.g., debit & credit together), atomic classes are not enough — use locks or higher-level constructs.
- High contention can reduce CAS efficiency, though still generally faster than synchronization.

KEYWORDS:
volatile vs synchronized vs AtomicInteger, atomicity, CAS (Compare-And-Swap), lock-free concurrency, thread-safe counter.

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

Author: Someshdiwan

Section19MultiThreading/Volatile and Atomic/src/VolatileCounter.java

@@ -1,34 +1,14 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 public class VolatileCounter {
-
     private AtomicInteger counter = new AtomicInteger(0);
 
     public void increament(){
         counter.incrementAndGet();
-
-    /*private volatile int counter = 0;
-
-    public void increament(){
-        counter++;
-    */
-
     }
 
-    /*
-    synchronized
-
-    Remove this synchronized and check the output.
-    othewise add volatile to the counter. Still not get 2000 using volatile.
-    Isko Bolte Atomicity. Har ek operation isolated rahe.
-    Java provides class to ensure a atomic city. like
-    atomic integer, atomic long, atomic boolean without using lock to achive isolationa and atomiccity
-    */
-
-    public int getCounter(){
+    public int getCounter() {
         return counter.get();
-
-        /* return counter;*/
     }
 
     public static void main(String[] args) throws InterruptedException {
@@ -47,10 +27,17 @@ public static void main(String[] args) throws InterruptedException {
 
         t1.start();
         t2.start();
-
         t1.join();
         t2.join();
-
         System.out.println(vc.getCounter());
     }
-}
+}
+
+/*
+Synchronized:
+Remove this synchronized and check the output.
+othewise add volatile to the counter. Still not get 2000 using volatile.
+Isko Bolte Atomicity. Har ek operation isolated rahe.
+Java provides class to ensure a atomic city. like
+atomic integer, atomic long, atomic boolean without using lock to achive isolationa and atomiccity
+*/