src/java.base/share/classes/jdk/internal/ref/CleanerImpl.java

@@ -26,23 +26,22 @@
 package jdk.internal.ref;
 
 import java.lang.ref.Cleaner;
 import java.lang.ref.Cleaner.Cleanable;
 import java.lang.ref.ReferenceQueue;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
 import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 
 import jdk.internal.misc.InnocuousThread;
 
 /**
  * CleanerImpl manages a set of object references and corresponding cleaning actions.
  * CleanerImpl provides the functionality of {@link java.lang.ref.Cleaner}.
  */
 public final class CleanerImpl implements Runnable {
+    private final static ThreadFactory THREAD_FACTORY =
+        new CleanerFactory.InnocuousThreadFactory();
 
     /**
      * An object to access the CleanerImpl from a Cleaner; set by Cleaner init.
      */
     private static Function<Cleaner, CleanerImpl> cleanerImplAccess = null;

@@ -105,11 +104,11 @@
         // schedule a nop cleaning action for the cleaner, so the associated thread
         // will continue to run at least until the cleaner is reclaimable.
         new CleanerCleanable(cleaner);
 
         if (threadFactory == null) {
-            threadFactory = CleanerImpl.InnocuousThreadFactory.factory();
+            threadFactory = THREAD_FACTORY;
         }
 
         // now that there's at least one cleaning action, for the cleaner,
         // we can start the associated thread, which runs until
         // all cleaning actions have been run.

@@ -309,36 +308,10 @@
         }
 
     }
 
     /**
-     * A ThreadFactory for InnocuousThreads.
-     * The factory is a singleton.
-     */
-    static final class InnocuousThreadFactory implements ThreadFactory {
-        final static ThreadFactory factory = new InnocuousThreadFactory();
-
-        static ThreadFactory factory() {
-            return factory;
-        }
-
-        final AtomicInteger cleanerThreadNumber = new AtomicInteger();
-
-        public Thread newThread(Runnable r) {
-            return AccessController.doPrivileged(new PrivilegedAction<Thread>() {
-                @Override
-                public Thread run() {
-                    Thread t = new InnocuousThread(r);
-                    t.setPriority(Thread.MAX_PRIORITY - 2);
-                    t.setName("Cleaner-" + cleanerThreadNumber.getAndIncrement());
-                    return t;
-                }
-            });
-        }
-    }
-
-    /**
      * A PhantomCleanable implementation for tracking the Cleaner itself.
      */
     static final class CleanerCleanable extends PhantomCleanable<Cleaner> {
         CleanerCleanable(Cleaner cleaner) {
             super(cleaner, cleaner);