8309406: Change jdk.trackAllThreads to default to true

Reviewed-by: rpressler, mchung, cjplummer

Author: Alan Bateman

src/java.base/share/classes/jdk/internal/vm/SharedThreadContainer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2023, 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
@@ -29,7 +29,6 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.LongAdder;
 import java.util.stream.Stream;
 import jdk.internal.access.JavaLangAccess;
 import jdk.internal.access.SharedSecrets;
@@ -50,16 +49,13 @@ public class SharedThreadContainer extends ThreadContainer implements AutoClosea
             VIRTUAL_THREADS = l.findVarHandle(SharedThreadContainer.class,
                     "virtualThreads", Set.class);
         } catch (Exception e) {
-            throw new InternalError(e);
+            throw new ExceptionInInitializerError(e);
         }
     }
 
     // name of container, used by toString
     private final String name;
 
-    // the number of threads in the container
-    private final LongAdder threadCount;
-
     // the virtual threads in the container, created lazily
     private volatile Set<Thread> virtualThreads;
 
@@ -76,7 +72,6 @@ public class SharedThreadContainer extends ThreadContainer implements AutoClosea
     private SharedThreadContainer(String name) {
         super(/*shared*/ true);
         this.name = name;
-        this.threadCount = new LongAdder();
     }
 
     /**
@@ -119,21 +114,14 @@ public void onStart(Thread thread) {
             }
             vthreads.add(thread);
         }
-        threadCount.add(1L);
     }
 
     @Override
     public void onExit(Thread thread) {
-        threadCount.add(-1L);
         if (thread.isVirtual())
             virtualThreads.remove(thread);
     }
 
-    @Override
-    public long threadCount() {
-        return threadCount.sum();
-    }
-
     @Override
     public Stream<Thread> threads() {
         // live platform threads in this container

src/java.base/share/classes/jdk/internal/vm/ThreadContainers.java

@@ -33,20 +33,35 @@
 import java.util.stream.Stream;
 import jdk.internal.access.JavaLangAccess;
 import jdk.internal.access.SharedSecrets;
-import sun.nio.ch.Poller;
 import sun.security.action.GetPropertyAction;
 
 /**
- * This class consists exclusively of static methods to support debugging and
- * monitoring of threads.
+ * This class consists exclusively of static methods to support groupings of threads.
  */
 public class ThreadContainers {
     private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
 
+    // true if all threads are tracked
+    private static final boolean TRACK_ALL_THREADS;
+
+    // the root container
+    private static final RootContainer ROOT_CONTAINER;
+
     // the set of thread containers registered with this class
     private static final Set<WeakReference<ThreadContainer>> CONTAINER_REGISTRY = ConcurrentHashMap.newKeySet();
     private static final ReferenceQueue<Object> QUEUE = new ReferenceQueue<>();
 
+    static {
+        String s = GetPropertyAction.privilegedGetProperty("jdk.trackAllThreads");
+        if (s == null || s.isEmpty() || Boolean.parseBoolean(s)) {
+            TRACK_ALL_THREADS = true;
+            ROOT_CONTAINER = new RootContainer.TrackingRootContainer();
+        } else {
+            TRACK_ALL_THREADS = false;
+            ROOT_CONTAINER = new RootContainer.CountingRootContainer();
+        }
+    }
+
     private ThreadContainers() { }
 
     /**
@@ -59,6 +74,13 @@ private static void expungeStaleEntries() {
         }
     }
 
+    /**
+     * Returns true if all threads are tracked.
+     */
+    public static boolean trackAllThreads() {
+        return TRACK_ALL_THREADS;
+    }
+
     /**
      * Registers a thread container to be tracked this class, returning a key
      * that is used to remove it from the registry.
@@ -83,7 +105,7 @@ public static void deregisterContainer(Object key) {
      * Returns the root thread container.
      */
     public static ThreadContainer root() {
-        return RootContainer.INSTANCE;
+        return ROOT_CONTAINER;
     }
 
     /**
@@ -183,20 +205,10 @@ private static ThreadContainer next(ThreadContainer container) {
     }
 
     /**
-     * Root container that "contains" all platform threads not started in a
-     * container plus some (or all) virtual threads that are started directly
-     * with the Thread API.
+     * Root container that "contains" all platform threads not started in a container.
+     * It may include all virtual threads started directly with the Thread API.
      */
     private static abstract class RootContainer extends ThreadContainer {
-        static final RootContainer INSTANCE;
-        static {
-            String s = GetPropertyAction.privilegedGetProperty("jdk.trackAllThreads");
-            if (s != null && (s.isEmpty() || Boolean.parseBoolean(s))) {
-                INSTANCE = new TrackingRootContainer();
-            } else {
-                INSTANCE = new CountingRootContainer();
-            }
-        }
         protected RootContainer() {
             super(true);
         }
@@ -270,11 +282,7 @@ public long threadCount() {
             }
             @Override
             public Stream<Thread> threads() {
-                // virtual threads in this container that are those blocked on I/O.
-                Stream<Thread> blockedVirtualThreads = Poller.blockedThreads()
-                        .filter(t -> t.isVirtual()
-                                && JLA.threadContainer(t) == this);
-                return Stream.concat(platformThreads(), blockedVirtualThreads);
+                return platformThreads();
             }
         }
     }

src/java.base/share/classes/jdk/internal/vm/ThreadDumper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2023, 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
@@ -240,7 +240,9 @@ private static void dumpThreadsToJson(ThreadContainer container,
         out.println("        ],");   // end of threads
 
         // thread count
-        threadCount = Long.max(threadCount, container.threadCount());
+        if (!ThreadContainers.trackAllThreads()) {
+            threadCount = Long.max(threadCount, container.threadCount());
+        }
         out.format("        \"threadCount\": \"%d\"%n", threadCount);
 
         if (more) {

test/hotspot/jtreg/serviceability/dcmd/thread/ThreadDumpToFileTest.java

@@ -66,7 +66,7 @@ void testPlainThreadDump() throws IOException {
     @Test
     void testJsonThreadDump() throws IOException {
         Path file = genThreadDumpPath(".json");
-        threadDump(file, "-format=json").shouldMatch("Created");
+        jcmdThreadDumpToFile(file, "-format=json").shouldMatch("Created");
 
         // parse the JSON text
         String jsonText = Files.readString(file);
@@ -89,7 +89,7 @@ void testDoNotOverwriteFile() throws IOException {
         Path file = genThreadDumpPath(".txt");
         Files.writeString(file, "xxx");
 
-        threadDump(file, "").shouldMatch("exists");
+        jcmdThreadDumpToFile(file, "").shouldMatch("exists");
 
         // file should not be overridden
         assertEquals("xxx", Files.readString(file));
@@ -102,14 +102,14 @@ void testDoNotOverwriteFile() throws IOException {
     void testOverwriteFile() throws IOException {
         Path file = genThreadDumpPath(".txt");
         Files.writeString(file, "xxx");
-        testPlainThreadDump(file, "-overwrite");
+        jcmdThreadDumpToFile(file, "-overwrite");
     }
 
     /**
      * Test thread dump in plain text format.
      */
     private void testPlainThreadDump(Path file, String... options) throws IOException {
-        threadDump(file, options).shouldMatch("Created");
+        jcmdThreadDumpToFile(file, options).shouldMatch("Created");
 
         // test that thread dump contains the name and id of the current thread
         String name = Thread.currentThread().getName();
@@ -118,21 +118,30 @@ private void testPlainThreadDump(Path file, String... options) throws IOExceptio
         assertTrue(find(file, expected), expected + " not found in " + file);
     }
 
+    /**
+     * Generate a file path with the given suffix to use for the thread dump.
+     */
     private Path genThreadDumpPath(String suffix) throws IOException {
         Path dir = Path.of(".").toAbsolutePath();
         Path file = Files.createTempFile(dir, "threads-", suffix);
         Files.delete(file);
         return file;
     }
 
-    private OutputAnalyzer threadDump(Path file, String... options) {
+    /**
+     * Launches jcmd Thread.dump_to_file to obtain a thread dump of this VM.
+     */
+    private OutputAnalyzer jcmdThreadDumpToFile(Path file, String... options) {
         String cmd = "Thread.dump_to_file";
         for (String option : options) {
             cmd += " " + option;
         }
         return new PidJcmdExecutor().execute(cmd + " " + file);
     }
 
+    /**
+     * Returns true if the given file contains a line with the string.
+     */
     private boolean find(Path file, String text) throws IOException {
         try (Stream<String> stream = Files.lines(file)) {
             return  stream.anyMatch(line -> line.indexOf(text) >= 0);