docs: add CAS (Compare-And-Swap) explanation and its role in ConcurrentLinkedDeque

Added detailed documentation explaining CAS (Compare-And-Swap) as the atomic
primitive behind Java’s lock-free concurrency model. Covers CAS mechanism,
advantages, limitations (ABA problem, spin-waiting), and its critical use in
ConcurrentLinkedDeque, Atomic classes, and other non-blocking data structures.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Queue Interface/Deque/Concurrent Linked Deque/src/CAS.txt

@@ -1,38 +1,48 @@
-CAS (Compare-And-Swap) is an atomic operation used in concurrent programming to achieve lock-free synchronization.
-It allows multiple threads to update a shared variable without using locks, improving performance in high-concurrency scenarios.
-
-How CAS Works?
-
-CAS involves three key components:
-
-Expected Value � The current value of a variable.
-New Value � The value we want to update to.
-Memory Location � The address of the variable being updated.
-
-Process:
-
-The CAS operation checks if the current value at a memory location matches the expected value.
-If it matches, the value is atomically updated to the new value.
-If it doesn�t match (i.e., another thread modified the value), the update fails, and the thread can retry.
-
-CAS in ConcurrentLinkedDeque:
-
-ConcurrentLinkedDeque is a non-blocking, thread-safe, double-ended queue.
-It relies on CAS operations to update nodes without locking.
-CAS ensures that operations like addFirst(), addLast(), removeFirst(), and removeLast() work concurrently without race conditions.
-
-Advantages of CAS:
-
-? Lock-free and non-blocking � Improves scalability in multithreaded environments.
-? Avoids thread contention � Unlike synchronized locks, CAS allows multiple threads to attempt updates without blocking.
-? Used in Java�s concurrent utilities � Found in AtomicInteger, AtomicReference, ConcurrentLinkedQueue, and more.
-
-Limitations of CAS:
-
-? ABA Problem � If a value changes from A ? B ? A, CAS might mistakenly assume no change occurred. Solution: Use AtomicStampedReference.
-? Spin-waiting overhead � If many threads repeatedly fail CAS, performance may degrade.
-
-
-CAS is a fundamental concept in concurrent programming, enabling efficient, lock-free updates.
-It plays a crucial role in Java�s concurrent collections like ConcurrentLinkedDeque, making them highly
-scalable and performant in multithreaded applications.
+|                  🔁 CAS (Compare-And-Swap)                    |
+|                                                               |
+| CAS is an atomic operation used in concurrent programming to  |
+| achieve lock-free synchronization. It allows multiple threads |
+| to update shared variables without using locks, improving     |
+| performance in high-concurrency scenarios.                    |
+|---------------------------------------------------------------|
+| How CAS Works:                                                |
+|---------------------------------------------------------------|
+| CAS involves three components:                                |
+|   • Expected Value  – the value the thread believes is current|
+|   • New Value       – the value to update if expectation holds|
+|   • Memory Location – the address of the shared variable      |
+
+| Process:                                                      |
+|   1. CAS checks if the current value equals the expected one. |
+|   2. If it matches → atomically updates to the new value.     |
+|   3. If not → update fails, and the thread retries.           |
+
+
+|           CAS in ConcurrentLinkedDeque:                       |
+| • ConcurrentLinkedDeque is a non-blocking, thread-safe        |
+|   double-ended queue.                                         |
+| • It relies on CAS to modify node pointers without locks.     |
+| • CAS ensures methods like addFirst(), addLast(),             |
+|   removeFirst(), and removeLast() operate concurrently        |
+|   without race conditions.                                    |
+|---------------------------------------------------------------|
+| Advantages of CAS:                                            |
+|---------------------------------------------------------------|
+| ✔ Lock-free and non-blocking — boosts scalability.            |
+| ✔ Avoids thread contention — no synchronized bottlenecks.     |
+| ✔ Widely used — core of AtomicInteger, AtomicReference,       |
+|   ConcurrentLinkedQueue, etc.                                 |
+|---------------------------------------------------------------|
+| Limitations of CAS:                                           |
+|---------------------------------------------------------------|
+| ⚠ ABA Problem — if value changes A→B→A, CAS may misdetect.    |
+|   • Solution: use AtomicStampedReference to tag updates.      |
+| ⚠ Spin-wait overhead — repeated CAS retries can slow down     |
+|   under heavy contention.                                     |
+
+|             Summary:                                          |
+| CAS is a cornerstone of modern lock-free design. It enables   |
+| efficient atomic updates without blocking threads, forming    |
+| the foundation of Java’s concurrent collections like          |
+| ConcurrentLinkedDeque for scalable multithreaded systems.     |
++---------------------------------------------------------------+