8269428: java/util/concurrent/ConcurrentHashMap/ToArray.java timed out

Reviewed-by: mdoerr
Backport-of: 570ad67204a55dd4b45e04e5a91671fed2cc18d0

Author: Andrew Lu

test/jdk/java/util/concurrent/ConcurrentHashMap/ToArray.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2004, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,6 +31,8 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -45,57 +47,62 @@ public static void main(String[] args) throws Throwable {
     }
 
     static void executeTest() throws Throwable {
-        final ConcurrentHashMap<Integer, Integer> m = new ConcurrentHashMap<>();
-        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
-        final int nCPU = Runtime.getRuntime().availableProcessors();
-        final int minWorkers = 2;
-        final int maxWorkers = Math.max(minWorkers, Math.min(32, nCPU));
-        final int nWorkers = rnd.nextInt(minWorkers, maxWorkers + 1);
-        final int sizePerWorker = 1024;
-        final int maxSize = nWorkers * sizePerWorker;
+        ExecutorService executor = Executors.newCachedThreadPool();
+        try {
+            final ConcurrentHashMap<Integer, Integer> m = new ConcurrentHashMap<>();
+            final ThreadLocalRandom rnd = ThreadLocalRandom.current();
+            final int nCPU = Runtime.getRuntime().availableProcessors();
+            final int minWorkers = 2;
+            final int maxWorkers = Math.max(minWorkers, Math.min(32, nCPU));
+            final int nWorkers = rnd.nextInt(minWorkers, maxWorkers + 1);
+            final int sizePerWorker = 1024;
+            final int maxSize = nWorkers * sizePerWorker;
 
-        // The foreman busy-checks that the size of the arrays obtained
-        // from the keys and values views grows monotonically until it
-        // reaches the maximum size.
+            // The foreman busy-checks that the size of the arrays obtained
+            // from the keys and values views grows monotonically until it
+            // reaches the maximum size.
 
-        // NOTE: these size constraints are not specific to toArray and are
-        // applicable to any form of traversal of the collection views
-        CompletableFuture<?> foreman = CompletableFuture.runAsync(new Runnable() {
-            private int prevSize = 0;
+            // NOTE: these size constraints are not specific to toArray and are
+            // applicable to any form of traversal of the collection views
+            CompletableFuture<?> foreman = CompletableFuture.runAsync(new Runnable() {
+                private int prevSize = 0;
 
-            private boolean checkProgress(Object[] a) {
-                int size = a.length;
-                if (size < prevSize || size > maxSize)
-                    throw new AssertionError(
-                        String.format("prevSize=%d size=%d maxSize=%d",
-                                      prevSize, size, maxSize));
-                prevSize = size;
-                return size == maxSize;
-            }
+                private boolean checkProgress(Object[] a) {
+                    int size = a.length;
+                    if (size < prevSize || size > maxSize)
+                        throw new AssertionError(
+                                String.format("prevSize=%d size=%d maxSize=%d",
+                                        prevSize, size, maxSize));
+                    prevSize = size;
+                    return size == maxSize;
+                }
 
-            public void run() {
-                Integer[] empty = new Integer[0];
-                for (;;)
-                    if (checkProgress(m.values().toArray())
-                        & checkProgress(m.keySet().toArray())
-                        & checkProgress(m.values().toArray(empty))
-                        & checkProgress(m.keySet().toArray(empty)))
-                        return;
-            }
-        });
+                public void run() {
+                    Integer[] empty = new Integer[0];
+                    for (; ; )
+                        if (checkProgress(m.values().toArray())
+                                & checkProgress(m.keySet().toArray())
+                                & checkProgress(m.values().toArray(empty))
+                                & checkProgress(m.keySet().toArray(empty)))
+                            return;
+                }
+            }, executor);
 
-        // Each worker puts globally unique keys into the map
-        List<CompletableFuture<?>> workers =
-            IntStream.range(0, nWorkers)
-            .mapToObj(w -> (Runnable) () -> {
-                for (int i = 0, o = w * sizePerWorker; i < sizePerWorker; i++)
-                    m.put(o + i, i);
-            })
-            .map(CompletableFuture::runAsync)
-            .collect(Collectors.toList());
+            // Each worker puts globally unique keys into the map
+            List<CompletableFuture<?>> workers =
+                    IntStream.range(0, nWorkers)
+                            .mapToObj(w -> (Runnable) () -> {
+                                for (int i = 0, o = w * sizePerWorker; i < sizePerWorker; i++)
+                                    m.put(o + i, i);
+                            })
+                            .map(r -> CompletableFuture.runAsync(r, executor))
+                            .collect(Collectors.toList());
 
-        // Wait for workers and foreman to complete
-        workers.forEach(CompletableFuture<?>::join);
-        foreman.join();
+            // Wait for workers and foreman to complete
+            workers.forEach(CompletableFuture<?>::join);
+            foreman.join();
+        } finally {
+            executor.shutdown();
+        }
     }
 }