feat(ThreadSafeHashTable): demonstrate synchronized thread-safe operations in Hashtable

What
- Added `ThreadSafeHashTable` class to showcase how `Hashtable` ensures thread safety with multiple writers.
- Spawned two threads:
  - Thread1 inserts keys 0 → 1000 with value `"New Thread1 Running"`.
  - Thread2 inserts keys 1000 → 1999 with value `"Thread2"`.
- Waited for both threads (`join()`).
- Printed final size of the map (`2000` entries).

Why
- To illustrate that unlike `HashMap`, all methods of `Hashtable` are synchronized.
- Validates safe concurrent access without external synchronization.
- Highlights the trade-off: thread safety but slower performance compared to non-synchronized collections.

How
- Step 1: Create a `Hashtable<Integer,String>` instance.
- Step 2: Define first thread to `put` entries for keys 0–1000.
- Step 3: Define second thread to `put` entries for keys 1000–1999.
- Step 4: Start both threads and `join()` to ensure completion.
- Step 5: Print `map.size()`, expected `2000`.

Logic
- Inputs: hard-coded key ranges (0–1999).
- Outputs: `"Final size of HashTable: 2000"`.
- Flow:
  1. Instantiate `Hashtable`.
  2. Launch two concurrent writers.
  3. Synchronization in `Hashtable` ensures correctness.
  4. Join threads.
  5. Print map size.

Real-life applications
- Legacy multi-threaded applications before `ConcurrentHashMap`.
- Small-scale shared maps where built-in synchronization is sufficient.
- Teaching concurrency safety basics in Java collections.

Notes
- `Hashtable` synchronizes all operations (method-level).
- This avoids corruption but limits scalability under high contention.
- For modern concurrent workloads, prefer `ConcurrentHashMap`.
- Demonstrates the classic synchronized map pattern and its impact.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Hash Table/src/ThreadSafeHashTable.java

@@ -0,0 +1,56 @@
+import java.util.Hashtable;
+
+/**
+ * Demonstrates thread-safety in {@link Hashtable}.
+ *
+ * <p>
+ * Key Points:
+ * <ul>
+ *   <li>Hashtable is synchronized → all its methods (including get/put) are thread-safe.</li>
+ *   <li>Multiple threads can update the Hashtable concurrently without corrupting data.</li>
+ *   <li>However, synchronization can cause performance overhead compared to non-synchronized maps like HashMap.</li>
+ * </ul>
+ *
+ * @author Somesh Diwan
+ */
+
+public class ThreadSafeHashTable {
+    public static void main(String[] args) {
+        /*
+          Concurrency in Hashtable:
+          - Unlike HashMap, Hashtable is thread-safe.
+          - Every method (including get() and put()) is synchronized.
+          - This ensures safe usage across multiple threads but makes it slower in single-threaded use cases.
+        */
+        Hashtable<Integer, String> map = new Hashtable<>();
+
+        // The first thread inserts keys from 0 to 1000
+        Thread newThread1 = new Thread(() -> {
+            for (int i = 0; i <= 1000; i++) {
+                map.put(i, "New Thread1 Running");
+            }
+        });
+
+        // The second thread inserted keys from 1000 to 1999
+        Thread thread2 = new Thread(() -> {
+            for (int i = 1000; i < 2000; i++) {
+                map.put(i, "Thread2");
+            }
+        });
+
+        // Start both threads
+        newThread1.start();
+        thread2.start();
+
+        // Wait for both threads to complete
+        try {
+            newThread1.join();
+            thread2.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        // The final size will be 2000 (keys 0–1999) — proving thread safety.
+        System.out.println("Final size of HashTable: " + map.size());
+    }
+}