The product cache that quietly loses writes

import java.util.*;
import java.util.concurrent.*;

/**
 * REFERENCE SOLUTION — shown only after the learner passes or gives up.
 *
 * ROOT CAUSE
 * ----------
 * HashMap has zero synchronization. Two threads calling put() concurrently race on:
 *
 *   1. the bucket array — thread A writes a Node into table[i], thread B
 *      overwrites the same slot with its own Node. A's entry is gone.
 *   2. `size` — a plain int. `++size` is read-modify-write, so increments are lost.
 *   3. resize() — two threads can build separate new tables; one is discarded
 *      along with everything written into it.
 *
 * All three are SILENT. No exception, no log, no CPU anomaly. The only symptom
 * is that the numbers are wrong, which is why this class of bug reaches prod.
 *
 * WHY NOT Collections.synchronizedMap(new HashMap<>())?
 * -----------------------------------------------------
 * It is correct, but it wraps every operation in one lock over the whole map.
 * A read-heavy cache — which is what this is — serialises every get() behind
 * that single monitor. ConcurrentHashMap locks per-bin on write and is
 * lock-free on read, so reads scale with cores instead of contending.
 *
 * WHY NOT just synchronized methods here?
 * ---------------------------------------
 * Same problem as synchronizedMap, plus you own the bug the next time someone
 * adds a method and forgets the keyword.
 *
 * THE DEEPER POINT
 * ----------------
 * Fixing the race makes this CORRECT. It does not make it a CACHE. An unbounded
 * map that is only ever written to is a memory leak with a friendly name.
 * A real cache needs a size ceiling and an expiry policy — see BoundedCache below.
 */
public class Solution {

    /** Fix 1 — correct, and scales for a read-heavy cache. */
    static class ProductCache {

        private final Map<String, String> cache = new ConcurrentHashMap<>();

        public void put(String sku, String name) {
            cache.put(sku, name);
        }

        public String get(String sku) {
            return cache.get(sku);
        }

        public int size() {
            return cache.size();
        }
    }

    /**
     * Fix 2 — the answer an interviewer actually wants at 4+ years.
     *
     * Bounded by capacity with LRU eviction. In real code reach for Caffeine,
     * which adds TTL, hit-rate stats and a far better eviction policy. This
     * version is here to show the mechanism rather than the dependency.
     *
     * Tradeoff being made explicitly: capping at maxEntries bounds memory, and
     * costs hit rate whenever the working set is larger than the cap. That is
     * a deliberate exchange — an unbounded cache trades an OutOfMemoryError for
     * a hit rate you never measured.
     */
    static class BoundedCache {

        private final Map<String, String> cache;

        BoundedCache(int maxEntries) {
            this.cache = Collections.synchronizedMap(
                new LinkedHashMap<>(16, 0.75f, true) {   // true = access order
                    @Override
                    protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
                        return size() > maxEntries;
                    }
                });
        }

        public void put(String sku, String name) { cache.put(sku, name); }
        public String get(String sku)            { return cache.get(sku); }
        public int size()                        { return cache.size(); }
    }

    public static void main(String[] args) throws Exception {
        ProductCache cache = new ProductCache();

        int threads = 8, perThread = 2_000, expected = threads * perThread;
        ExecutorService pool = Executors.newFixedThreadPool(threads);
        CountDownLatch start = new CountDownLatch(1);

        for (int t = 0; t < threads; t++) {
            final int id = t;
            pool.submit(() -> {
                try {
                    start.await();
                    for (int i = 0; i < perThread; i++) {
                        cache.put("SKU-" + id + "-" + i, "product-" + id + "-" + i);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        start.countDown();
        pool.shutdown();
        pool.awaitTermination(30, TimeUnit.SECONDS);

        int missing = 0;
        for (int t = 0; t < threads; t++)
            for (int i = 0; i < perThread; i++)
                if (cache.get("SKU-" + t + "-" + i) == null) missing++;

        System.out.println("expected entries = " + expected);
        System.out.println("actual   entries = " + cache.size());
        System.out.println("lost writes      = " + (expected - cache.size()));
        System.out.println("unreadable keys  = " + missing);
        System.out.println(missing == 0 && cache.size() == expected ? "PASS" : "FAIL");
    }
}