feat: add ConcurrentSkipListMapExample with concurrent writers

What
- Implemented `ConcurrentSkipListMapExample` demo.
- Demonstrates concurrent writes + iteration using `ConcurrentSkipListMap`.
- Showcases sorted operations (`firstKey`, `lastKey`, `subMap`).

Why
- To illustrate how `ConcurrentSkipListMap` behaves under concurrent updates.
- Highlights weakly-consistent iterators that tolerate concurrent modifications.
- Shows real-time insertion by two threads (odd/even writers).

How
- Created `ConcurrentSkipListMap<Integer, String>`.
- Preloaded keys `50`, `10`, `30`, `70`.
- Spawned two threads:
  - `writer-odd` → inserts odd keys with values `"vX"`.
  - `writer-even` → inserts even keys with values `"vX"`.
- Iterated concurrently over `map.entrySet()` (may reflect partial updates).
- After joining threads, printed:
  - First/last key
  - A submap view `[10..30]`.

Logic
- Iteration is weakly-consistent → doesn’t throw `ConcurrentModificationException`.
- Map maintains natural ordering of keys.
- Range queries like `subMap`, `headMap`, `tailMap` work efficiently.

Real-world use
- Thread-safe sorted maps for caches, leaderboards, or time-series data.
- Useful when concurrent writes + ordered reads are required.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Concurrent HashMap/Concurrent Skip List Map/src/ConcurrentSkipListMapExample.java

@@ -0,0 +1,48 @@
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+
+public class ConcurrentSkipListMapExample {
+    public static void main(String[] args) throws InterruptedException {
+        ConcurrentSkipListMap<Integer, String> map = new ConcurrentSkipListMap<>();
+
+        // Put some entries (not blocking)
+        map.put(50, "fifty");
+        map.put(10, "ten");
+        map.put(30, "thirty");
+        map.put(70, "seventy");
+
+        // Start writers concurrently
+        Thread writer1 = new Thread(() -> {
+            for (int i = 1; i <= 100; i += 2) {
+                map.put(i, "v" + i);
+            }
+        }, "writer-odd");
+
+        Thread writer2 = new Thread(() -> {
+            for (int i = 2; i <= 100; i += 2) {
+                map.put(i, "v" + i);
+            }
+        }, "writer-even");
+
+        writer1.start();
+        writer2.start();
+
+        // Meanwhile, iterate using weakly consistent iterator
+        for (Map.Entry<Integer, String> e : map.entrySet()) {
+            System.out.println(e.getKey() + " -> " + e.getValue());
+            // Note: iteration may miss or include concurrent updates
+        }
+
+        writer1.join();
+        writer2.join();
+
+        // After writers finish, map is sorted
+        System.out.println("First key: " + map.firstKey());
+        System.out.println("Last key: " + map.lastKey());
+
+        // Get a subMap view (sorted)
+        NavigableMap<Integer, String> sub = map.subMap(10, true, 30, true);
+        System.out.println("Submap [10..30]: " + sub);
+    }
+}