ICU-23321 ResourceCache: replace synchronized trie with ConcurrentHashMap

Replace the custom synchronized trie in ICUResourceBundleReader.ResourceCache
with ConcurrentHashMap, eliminating a heavily contended lock on the resource
loading path.

ResourceCache.get() was synchronized and called on every resource bundle
access (getString, getAlias, getArray, getTable). The custom trie (ICU-10932,
2014) optimized memory via int[]/Object[] arrays to avoid Integer autoboxing,
but its sparse power-of-2 allocations waste 94.8% of slots (39KB vs 13KB per
cache with ConcurrentHashMap).

Benchmark (NumberFormat.getInstance full stack):
  1 thread:  543 -> 505 ops/ms (slight regression from autoboxing)
  32 threads: 2,074 -> 4,051 ops/ms (2x improvement from lock elimination)

Uses ConcurrentHashMap.compute() in the put path to atomically handle cleared
SoftReferences (plain putIfAbsent cannot replace a non-null but dead entry).

Author: jabagawee

icu4j/main/core/src/main/java/com/ibm/icu/impl/ICUResourceBundleReader.java

@@ -21,7 +21,7 @@
 import java.nio.CharBuffer;
 import java.nio.IntBuffer;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * This class reads the *.res resource bundle format.
@@ -139,7 +139,7 @@ public boolean isDataVersionAcceptable(byte formatVersion[]) {
 
     private ResourceCache resourceCache;
 
-    private static ReaderCache CACHE = new ReaderCache();
+    private static final ReaderCache CACHE = new ReaderCache();
     private static final ICUResourceBundleReader NULL_READER = new ICUResourceBundleReader();
 
     private static class ReaderCacheKey {
@@ -323,7 +323,7 @@ private void init(ByteBuffer inBytes) throws IOException {
         }
 
         if (!isPoolBundle || b16BitUnits.length() > 1) {
-            resourceCache = new ResourceCache(maxOffset);
+            resourceCache = new ResourceCache();
         }
 
         // Reset the position for future .asCharBuffer() etc.
@@ -1167,232 +1167,70 @@ int getContainerResource(ICUResourceBundleReader reader, int index) {
      * mapped. Integers need not and should not be cached. Multiple .res items may share resource
      * offsets (genrb eliminates some duplicates).
      *
-     * <p>This cache uses int[] and Object[] arrays to minimize object creation and avoid
-     * auto-boxing.
-     *
      * <p>Large resource objects are usually stored in SoftReferences.
      *
-     * <p>For few resources, a small table is used with binary search. When more resources are
-     * cached, then the data structure changes to be faster but also use more memory.
+     * <p>This replaces the previous custom trie structure (ICU-10932, 2014) with ConcurrentHashMap
+     * for lock-free concurrent reads. Benchmarking shows CHM uses ~3x less memory than the trie at
+     * typical ICU bundle sizes (~221 entries/cache) due to the trie's sparse power-of-2 Level
+     * arrays (5% utilization), while providing ~2x better throughput at 32 threads by eliminating
+     * the synchronized bottleneck on every resource lookup.
      */
     private static final class ResourceCache {
-        // Number of items to be stored in a simple array with binary search and insertion sort.
-        private static final int SIMPLE_LENGTH = 32;
-
-        // When more than SIMPLE_LENGTH items are cached,
-        // then switch to a trie-like tree of levels with different array lengths.
-        private static final int ROOT_BITS = 7;
-        private static final int NEXT_BITS = 6;
-
-        // Simple table, used when length >= 0.
-        private int[] keys = new int[SIMPLE_LENGTH];
-        private Object[] values = new Object[SIMPLE_LENGTH];
-        private int length;
-
-        // Trie-like tree of levels, used when length < 0.
-        private int maxOffsetBits;
-
-        /** Number of bits in each level, each stored in a nibble. */
-        private int levelBitsList;
-
-        private Level rootLevel;
+        private final ConcurrentHashMap<Integer, Object> map;
 
         private static boolean storeDirectly(int size) {
             return size < LARGE_SIZE || CacheValue.futureInstancesWillBeStrong();
         }
 
-        @SuppressWarnings("unchecked")
-        private static final Object putIfCleared(
-                Object[] values, int index, Object item, int size) {
-            Object value = values[index];
-            if (!(value instanceof SoftReference)) {
-                // The caller should be consistent for each resource,
-                // that is, create equivalent objects of equal size every time,
-                // but the CacheValue "strength" may change over time.
-                // assert size < LARGE_SIZE;
-                return value;
-            }
-            assert size >= LARGE_SIZE;
-            value = ((SoftReference<Object>) value).get();
-            if (value != null) {
-                return value;
-            }
-            values[index] =
-                    CacheValue.futureInstancesWillBeStrong() ? item : new SoftReference<>(item);
-            return item;
-        }
-
-        private static final class Level {
-            int levelBitsList;
-            int shift;
-            int mask;
-            int[] keys;
-            Object[] values;
-
-            Level(int levelBitsList, int shift) {
-                this.levelBitsList = levelBitsList;
-                this.shift = shift;
-                int bits = levelBitsList & 0xf;
-                assert bits != 0;
-                int length = 1 << bits;
-                mask = length - 1;
-                keys = new int[length];
-                values = new Object[length];
-            }
-
-            Object get(int key) {
-                int index = (key >> shift) & mask;
-                int k = keys[index];
-                if (k == key) {
-                    return values[index];
-                }
-                if (k == 0) {
-                    Level level = (Level) values[index];
-                    if (level != null) {
-                        return level.get(key);
-                    }
-                }
-                return null;
-            }
-
-            Object putIfAbsent(int key, Object item, int size) {
-                int index = (key >> shift) & mask;
-                int k = keys[index];
-                if (k == key) {
-                    return putIfCleared(values, index, item, size);
-                }
-                if (k == 0) {
-                    Level level = (Level) values[index];
-                    if (level != null) {
-                        return level.putIfAbsent(key, item, size);
-                    }
-                    keys[index] = key;
-                    values[index] = storeDirectly(size) ? item : new SoftReference<>(item);
-                    return item;
-                }
-                // Collision: Add a child level, move the old item there,
-                // and then insert the current item.
-                Level level = new Level(levelBitsList >> 4, shift + (levelBitsList & 0xf));
-                int i = (k >> level.shift) & level.mask;
-                level.keys[i] = k;
-                level.values[i] = values[index];
-                keys[index] = 0;
-                values[index] = level;
-                return level.putIfAbsent(key, item, size);
-            }
-        }
-
-        ResourceCache(int maxOffset) {
-            assert maxOffset != 0;
-            maxOffsetBits = 28;
-            while (maxOffset <= 0x7ffffff) {
-                maxOffset <<= 1;
-                --maxOffsetBits;
-            }
-            int keyBits = maxOffsetBits + 2; // +2 for mini type: at most 30 bits used in a key
-            // Precompute for each level the number of bits it handles.
-            if (keyBits <= ROOT_BITS) {
-                levelBitsList = keyBits;
-            } else if (keyBits < (ROOT_BITS + 3)) {
-                levelBitsList = 0x30 | (keyBits - 3);
-            } else {
-                levelBitsList = ROOT_BITS;
-                keyBits -= ROOT_BITS;
-                int shift = 4;
-                for (; ; ) {
-                    if (keyBits <= NEXT_BITS) {
-                        levelBitsList |= keyBits << shift;
-                        break;
-                    } else if (keyBits < (NEXT_BITS + 3)) {
-                        levelBitsList |= (0x30 | (keyBits - 3)) << shift;
-                        break;
-                    } else {
-                        levelBitsList |= NEXT_BITS << shift;
-                        keyBits -= NEXT_BITS;
-                        shift += 4;
-                    }
-                }
-            }
-        }
-
-        /**
-         * Turns a resource integer (with unused bits in the middle) into a key with fewer bits (at
-         * most keyBits).
-         */
-        private int makeKey(int res) {
-            // It is possible for resources of different types in the 16-bit array
-            // to share a start offset; distinguish between those with a 2-bit value,
-            // as a tie-breaker in the bits just above the highest possible offset.
-            // It is not possible for "regular" resources of different types
-            // to share a start offset with each other,
-            // but offsets for 16-bit and "regular" resources overlap;
-            // use 2-bit value 0 for "regular" resources.
-            int type = RES_GET_TYPE(res);
-            int miniType =
-                    (type == ICUResourceBundle.STRING_V2)
-                            ? 1
-                            : (type == ICUResourceBundle.TABLE16)
-                                    ? 3
-                                    : (type == ICUResourceBundle.ARRAY16) ? 2 : 0;
-            return RES_GET_OFFSET(res) | (miniType << maxOffsetBits);
-        }
-
-        private int findSimple(int key) {
-            return Arrays.binarySearch(keys, 0, length, key);
+        ResourceCache() {
+            map = new ConcurrentHashMap<>();
         }
 
         @SuppressWarnings("unchecked")
-        synchronized Object get(int res) {
+        Object get(int res) {
             // Integers and empty resources need not be cached.
-            // The cache itself uses res=0 for "no match".
             assert RES_GET_OFFSET(res) != 0;
-            Object value;
-            if (length >= 0) {
-                int index = findSimple(res);
-                if (index >= 0) {
-                    value = values[index];
-                } else {
-                    return null;
-                }
-            } else {
-                value = rootLevel.get(makeKey(res));
-                if (value == null) {
-                    return null;
-                }
+            Integer resKey = res;
+            Object value = map.get(resKey);
+            if (value == null) {
+                return null;
             }
             if (value instanceof SoftReference) {
-                value = ((SoftReference<Object>) value).get();
-            }
-            return value; // null if the reference was cleared
-        }
-
-        synchronized Object putIfAbsent(int res, Object item, int size) {
-            if (length >= 0) {
-                int index = findSimple(res);
-                if (index >= 0) {
-                    return putIfCleared(values, index, item, size);
-                } else if (length < SIMPLE_LENGTH) {
-                    index = ~index;
-                    if (index < length) {
-                        System.arraycopy(keys, index, keys, index + 1, length - index);
-                        System.arraycopy(values, index, values, index + 1, length - index);
-                    }
-                    ++length;
-                    keys[index] = res;
-                    values[index] = storeDirectly(size) ? item : new SoftReference<>(item);
-                    return item;
-                } else /* not found && length == SIMPLE_LENGTH */ {
-                    // Grow to become trie-like.
-                    rootLevel = new Level(levelBitsList, 0);
-                    for (int i = 0; i < SIMPLE_LENGTH; ++i) {
-                        rootLevel.putIfAbsent(makeKey(keys[i]), values[i], 0);
-                    }
-                    keys = null;
-                    values = null;
-                    length = -1;
+                Object referent = ((SoftReference<Object>) value).get();
+                if (referent == null) {
+                    // SoftReference was cleared by GC. Remove the dead entry to prevent
+                    // unbounded accumulation. Two-arg remove avoids ABA race.
+                    map.remove(resKey, value);
                 }
+                return referent;
             }
-            return rootLevel.putIfAbsent(makeKey(res), item, size);
+            return value;
+        }
+
+        @SuppressWarnings("unchecked")
+        Object putIfAbsent(int res, Object item, int size) {
+            // Use compute() for both paths to atomically handle cleared SoftReferences.
+            // putIfAbsent() cannot replace a cleared SoftReference (non-null but dead),
+            // which would return null to the caller.
+            Integer resKey = res;
+            Object[] result = new Object[] {item};
+            map.compute(
+                    resKey,
+                    (key, existing) -> {
+                        if (existing != null) {
+                            Object val =
+                                    existing instanceof SoftReference
+                                            ? ((SoftReference<Object>) existing).get()
+                                            : existing;
+                            if (val != null) {
+                                result[0] = val;
+                                return existing;
+                            }
+                        }
+                        result[0] = item;
+                        return storeDirectly(size) ? item : new SoftReference<>(item);
+                    });
+            return result[0];
         }
     }
 

icu4j/main/core/src/test/java/com/ibm/icu/dev/test/util/ConcurrencyTest.java

@@ -0,0 +1,90 @@
+// © 2026 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+package com.ibm.icu.dev.test.util;
+
+import com.ibm.icu.dev.test.CoreTestFmwk;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CyclicBarrier;
+import org.junit.Assume;
+
+/**
+ * Base class for concurrent regression tests. Spins up {@link #THREAD_COUNT} threads, synchronizes
+ * them at a barrier, runs the task, and collects errors. Threads that hang past {@link #TIMEOUT_MS}
+ * trigger a failure with diagnostic info.
+ *
+ * <p>Tests are skipped unless exhaustiveness >= 5 (pass {@code -DICU.exhaustive=5} to Maven).
+ */
+public abstract class ConcurrencyTest extends CoreTestFmwk {
+
+    protected static final int THREAD_COUNT = 16;
+    protected static final int ITERATIONS = 2_000;
+    private static final long TIMEOUT_MS = 30_000;
+    private static final int MIN_EXHAUSTIVENESS = 5;
+
+    @FunctionalInterface
+    protected interface ConcurrentTask {
+        void run(int threadId) throws Exception;
+    }
+
+    protected void runConcurrent(String testName, ConcurrentTask task) throws Exception {
+        Assume.assumeTrue(
+                "Concurrency tests require exhaustiveness >= "
+                        + MIN_EXHAUSTIVENESS
+                        + " (use -e "
+                        + MIN_EXHAUSTIVENESS
+                        + ")",
+                getExhaustiveness() >= MIN_EXHAUSTIVENESS);
+
+        final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT);
+        final List<Throwable> errors = Collections.synchronizedList(new ArrayList<>());
+
+        Thread[] threads = new Thread[THREAD_COUNT];
+        for (int t = 0; t < THREAD_COUNT; t++) {
+            final int tid = t;
+            threads[t] =
+                    new Thread(
+                            () -> {
+                                try {
+                                    barrier.await();
+                                    task.run(tid);
+                                } catch (Throwable e) {
+                                    errors.add(e);
+                                }
+                            },
+                            testName + "-thread-" + t);
+            threads[t].start();
+        }
+
+        for (Thread thread : threads) {
+            thread.join(TIMEOUT_MS);
+        }
+        List<String> hung = new ArrayList<>();
+        for (Thread thread : threads) {
+            if (thread.isAlive()) {
+                hung.add(thread.getName());
+                thread.interrupt();
+            }
+        }
+        if (!hung.isEmpty()) {
+            fail(
+                    testName
+                            + ": threads still alive after "
+                            + TIMEOUT_MS
+                            + "ms (possible deadlock): "
+                            + String.join(", ", hung));
+        }
+        if (!errors.isEmpty()) {
+            Throwable first = errors.get(0);
+            fail(
+                    testName
+                            + ": "
+                            + errors.size()
+                            + " thread(s) threw exceptions. First: "
+                            + first.getClass().getName()
+                            + ": "
+                            + first.getMessage());
+        }
+    }
+}