docs(concurrency): add detailed comparison of volatile and AtomicInteger in Java

What
- Added documentation explaining differences between `volatile` and `AtomicInteger` in multithreaded programming.
- Covered:
  1. **Volatile**
     - Guarantees visibility (reads/writes go to main memory).
     - Does not guarantee atomicity.
     - Example: `volatile int count = 0;` → `count++` is not atomic and can lead to lost updates.
  2. **AtomicInteger**
     - Provides atomic operations (`incrementAndGet()`, `compareAndSet()`).
     - Lock-free, CAS-based, ensuring both visibility and atomicity.
     - Example: `AtomicInteger count = new AtomicInteger(0);` → `count.incrementAndGet()` ensures safe increments.
  3. **When to Use**
     - Use `volatile` for flags (simple read/write state variables).
     - Use `AtomicInteger` for counters or shared mutable integers requiring atomic updates.

Why
- Clarifies a common misconception: that `volatile` alone ensures thread-safety.
- Highlights that atomicity requires `AtomicInteger` (or synchronization), not just visibility.
- Provides practical guidance on choosing between the two.

Logic
- **Volatile semantics**: read/write operations are always visible to all threads immediately, but compound actions like `count++` are still unsafe because they break into multiple non-atomic steps (read → increment → write).
- **AtomicInteger semantics**: all key operations (increment, compare-and-swap) are atomic, leveraging CPU-level CAS instructions. No race conditions occur.
- **Decision point**:
  - Use `volatile` when you only need a one-way signal or visibility guarantee.
  - Use `AtomicInteger` when multiple threads must safely modify a shared counter without locking.

Key Takeaways
✔ `volatile` → visibility only, not atomicity.
✔ `count++` with `volatile` can lose updates under concurrency.
✔ `AtomicInteger` → provides lock-free atomic operations with visibility.
✔ Ideal for counters, accumulators, and CAS logic.
✔ Use `volatile` for flags (boolean control variables), not for shared mutable counters.

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

Author: Someshdiwan

JAVA8/🧠 volatile vs AtomicInteger in Java.txt

@@ -0,0 +1,69 @@
+Volatile vs AtomicInteger in Java:
+
+1. Volatile
+- volatile is a Java keyword used to mark a variable so that:
+  - Reads and writes go directly to main memory (no thread-local caching).
+  - Visibility is guaranteed: when one thread updates a volatile variable,
+    other threads see the updated value immediately.
+
+What it does:
+- Ensures **visibility** across threads.
+
+What it does not do:
+- Does NOT ensure **atomicity**.
+- Operations like count++ are not atomic, since they involve
+  read → modify → write.
+
+Example where volatile fails:
+
+volatile int count = 0;
+
+public void increment() {
+    count++; // Not atomic: multiple threads may overwrite each other.
+}
+
+Problem:
+- If two threads read the same value of count (say 10),
+  both increment and write back 11, losing one update.
+
+2. AtomicInteger
+- AtomicInteger is part of `java.util.concurrent.atomic` package.
+- Provides atomic operations such as:
+  - incrementAndGet()
+  - getAndIncrement()
+  - compareAndSet()
+
+- Ensures **atomicity** and **thread safety** without explicit synchronization.
+- Uses lock-free, non-blocking CAS (Compare-And-Swap) under the hood.
+
+Example with AtomicInteger:
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+AtomicInteger count = new AtomicInteger(0);
+
+public void increment() {
+    count.incrementAndGet(); // Atomic and thread-safe
+}
+
+Behavior:
+- Each thread increments safely.
+- No lost updates.
+- Faster than synchronized methods in many cases.
+
+3. When to Use What?
+- Use volatile when:
+  - You only need a **flag** (true/false, ready/done).
+  - You just care about visibility of a single write/read.
+  - Example: volatile boolean isRunning;
+
+- Use AtomicInteger when:
+  - You need **atomic operations** like counting, accumulating,
+    or compare-and-set in multi-threaded contexts.
+  - Example: safely counting user requests in a server.
+
+
+
+- volatile → Guarantees visibility, but not atomicity.
+- AtomicInteger → Guarantees both visibility and atomicity for integer operations, using efficient
+                  CAS-based lock-free mechanisms.