8344461: Additional cleanup in NewThreadAction

8344867: Cleanup unneeded qualified exports to java.rmi

Co-authored-by: Roger Riggs <rriggs@openjdk.org>
Reviewed-by: rriggs

Author: Stuart Marks

src/java.base/share/classes/module-info.java

@@ -316,7 +316,6 @@
     exports sun.reflect.misc to
         java.desktop,
         java.management,
-        java.rmi,
         java.sql.rowset;
     exports sun.security.internal.interfaces to
         jdk.crypto.cryptoki;
@@ -329,7 +328,6 @@
     exports sun.security.pkcs to
         jdk.jartool;
     exports sun.security.provider to
-        java.rmi,
         java.security.jgss,
         jdk.crypto.cryptoki,
         jdk.security.auth;
@@ -344,7 +342,6 @@
         jdk.jartool;
     exports sun.security.util to
         java.naming,
-        java.rmi,
         java.security.jgss,
         java.security.sasl,
         java.smartcardio,

src/java.rmi/share/classes/sun/rmi/runtime/NewThreadAction.java

@@ -36,10 +36,46 @@
  * There is a single instance of this class, which can be obtained
  * with a getInstance() call.
  *
+ * This class also contains a couple static methods for creating
+ * threads. The methods allow the choice of the Runnable for the
+ * new thread to execute, the name of the new thread (which will
+ * be prefixed with "RMI "), and whether or not it will be a daemon
+ * thread.
+ *
+ * The new thread may be created in the system thread group (the root
+ * of the thread group tree) or an internally created non-system
+ * thread group (the "user" thread group).
+ *
+ * The new thread will have the system class loader as its initial
+ * context class loader (that is, its context class loader will NOT be
+ * inherited from the current thread).
+ *
  * @author      Peter Jones
  **/
 public final class RuntimeUtil {
 
+    /**
+     * Cached reference to the system (root) thread group.
+     */
+    private static final ThreadGroup systemThreadGroup;
+    static {
+        ThreadGroup group = Thread.currentThread().getThreadGroup();
+        ThreadGroup parent;
+        while ((parent = group.getParent()) != null) {
+            group = parent;
+        }
+        systemThreadGroup = group;
+    }
+
+    /**
+     * Special child of the system thread group for running tasks that
+     * may execute user code. The need for a separate thread group may
+     * be a vestige of it having had a different security policy from
+     * the system thread group, so this might no longer be necessary.
+     */
+    private static final ThreadGroup userThreadGroup =
+        new ThreadGroup(systemThreadGroup, "RMI Runtime");
+
     /** runtime package log */
     private static final Log runtimeLog =
         Log.getLog("sun.rmi.runtime", null, false);
@@ -54,16 +90,25 @@ public final class RuntimeUtil {
     /** thread pool for scheduling delayed tasks */
     private final ScheduledThreadPoolExecutor scheduler;
 
+    /**
+     * Creates the single instance of RuntimeUtil. Note that this is called
+     * from a static initializer, and it has a ThreadFactory that calls
+     * static methods on this class, possibly from other threads. This
+     * should be ok, as the ScheduledThreadPoolExecutor constructor
+     * returns immediately without blocking on the creation of threads
+     * by the factory.
+     */
     private RuntimeUtil() {
         scheduler = new ScheduledThreadPoolExecutor(
             schedulerThreads,
             new ThreadFactory() {
                 private final AtomicInteger count = new AtomicInteger();
                 public Thread newThread(Runnable runnable) {
                     try {
-                        return new NewThreadAction(runnable,
+                        return newSystemThread(
+                            runnable,
                             "Scheduler(" + count.getAndIncrement() + ")",
-                            true).run();
+                            true);
                     } catch (Throwable t) {
                         runtimeLog.log(Level.WARNING,
                                        "scheduler thread factory throws", t);
@@ -93,4 +138,48 @@ public static RuntimeUtil getInstance() {
     public ScheduledThreadPoolExecutor getScheduler() {
         return scheduler;
     }
+
+    // Thread creation methods.
+
+    /**
+     * Internal method to create a new thread with the given settings.
+     *
+     * @param group the thread group, should be systemThreadGroup or userThreadGroup
+     * @param runnable the thread's task
+     * @param name the thread's name, which will be prefixed with "RMI "
+     * @param daemon whether the thread should be a daemon
+     * @return the newly created thread
+     */
+    private static Thread newThread(ThreadGroup group, Runnable runnable, String name, boolean daemon) {
+        Thread t = new Thread(group, runnable, "RMI " + name);
+        t.setContextClassLoader(ClassLoader.getSystemClassLoader());
+        t.setDaemon(daemon);
+        return t;
+    }
+
+    /**
+     * Creates and returns, but does not start, a new thread with the given settings.
+     * The thread will be in the system ("root") thread group.
+     *
+     * @param runnable the thread's task
+     * @param name the thread's name, which will be prefixed with "RMI "
+     * @param daemon whether the thread should be a daemon
+     * @return the newly created thread
+     */
+    public static Thread newSystemThread(Runnable runnable, String name, boolean daemon) {
+        return newThread(systemThreadGroup, runnable, name, daemon);
+    }
+
+    /**
+     * Creates and returns, but does not start, a new thread with the given settings.
+     * The thread will be in the RMI user thread group.
+     *
+     * @param runnable the thread's task
+     * @param name the thread's name, which will be prefixed with "RMI "
+     * @param daemon whether the thread should be a daemon
+     * @return the newly created thread
+     */
+    public static Thread newUserThread(Runnable runnable, String name, boolean daemon) {
+        return newThread(userThreadGroup, runnable, name, daemon);
+    }
 }

src/java.rmi/share/classes/sun/rmi/runtime/RuntimeUtil.java

@@ -41,7 +41,7 @@
 import java.rmi.server.ObjID;
 
 import sun.rmi.runtime.Log;
-import sun.rmi.runtime.NewThreadAction;
+import sun.rmi.runtime.RuntimeUtil;
 import sun.rmi.server.UnicastRef;
 import sun.rmi.server.Util;
 
@@ -237,8 +237,7 @@ private EndpointEntry(final Endpoint endpoint) {
                 throw new Error("internal error creating DGC stub");
             }
             renewCleanThread =
-                new NewThreadAction(new RenewCleanThread(),
-                                    "RenewClean-" + endpoint, true).run();
+                RuntimeUtil.newSystemThread(new RenewCleanThread(), "RenewClean-" + endpoint, true);
             renewCleanThread.start();
         }
 

src/java.rmi/share/classes/sun/rmi/transport/DGCClient.java

@@ -33,7 +33,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import sun.rmi.runtime.Log;
-import sun.rmi.runtime.NewThreadAction;
+import sun.rmi.runtime.RuntimeUtil;
 
 /**
  * Object table shared by all implementors of the Transport interface.
@@ -271,7 +271,7 @@ static void incrementKeepAliveCount() {
             keepAliveCount++;
 
             if (reaper == null) {
-                reaper = new NewThreadAction(new Reaper(), "Reaper", false).run();
+                reaper = RuntimeUtil.newSystemThread(new Reaper(), "Reaper", false);
                 reaper.start();
             }
 

src/java.rmi/share/classes/sun/rmi/transport/ObjectTable.java

@@ -31,7 +31,7 @@
 import java.rmi.server.Unreferenced;
 import java.util.*;
 import sun.rmi.runtime.Log;
-import sun.rmi.runtime.NewThreadAction;
+import sun.rmi.runtime.RuntimeUtil;
 import sun.rmi.server.Dispatcher;
 
 /**
@@ -312,10 +312,10 @@ private synchronized void refSetRemove(VMID vmid) {
              */
             Remote obj = getImpl();
             if (obj instanceof Unreferenced unrefObj) {
-                new NewThreadAction(() -> {
+                RuntimeUtil.newUserThread(() -> {
                     Thread.currentThread().setContextClassLoader(ccl);
                     unrefObj.unreferenced();
-                }, "Unreferenced-" + nextThreadNum++, false, true).run().start();
+                }, "Unreferenced-" + nextThreadNum++, false).start();
                 // REMIND: access to nextThreadNum not synchronized; you care?
             }
 

src/java.rmi/share/classes/sun/rmi/transport/Target.java

@@ -37,7 +37,6 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import sun.rmi.runtime.Log;
-import sun.rmi.runtime.NewThreadAction;
 import sun.rmi.runtime.RuntimeUtil;
 import sun.rmi.transport.Channel;
 import sun.rmi.transport.Connection;
@@ -401,9 +400,9 @@ public ConnectionAcceptor(TCPTransport transport) {
      * Start a new thread to accept connections.
      */
     public void startNewAcceptor() {
-        Thread t = new NewThreadAction(ConnectionAcceptor.this,
-                                       "TCPChannel Accept-" + ++ threadNum,
-                                       true).run();
+        Thread t = RuntimeUtil.newSystemThread(ConnectionAcceptor.this,
+                                               "TCPChannel Accept-" + ++ threadNum,
+                                               true);
         t.start();
     }
 

src/java.rmi/share/classes/sun/rmi/transport/tcp/TCPChannel.java

@@ -45,7 +45,7 @@
 import java.util.Map;
 import java.util.Set;
 import sun.rmi.runtime.Log;
-import sun.rmi.runtime.NewThreadAction;
+import sun.rmi.runtime.RuntimeUtil;
 import sun.rmi.transport.Channel;
 import sun.rmi.transport.Endpoint;
 import sun.rmi.transport.Target;
@@ -752,7 +752,7 @@ static String attemptFQDN(InetAddress localAddr)
         private void getFQDN() {
 
             /* FQDN finder will run in RMI threadgroup. */
-            Thread t = new NewThreadAction(FQDN.this, "FQDN Finder", true).run();
+            Thread t = RuntimeUtil.newSystemThread(FQDN.this, "FQDN Finder", true);
             t.start();
         }