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

*** 26,48 ****
  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 {
  
      /**
       * An object to access the CleanerImpl from a Cleaner; set by Cleaner init.
       */
      private static Function<Cleaner, CleanerImpl> cleanerImplAccess = null;
--- 26,47 ----
  package jdk.internal.ref;
  
  import java.lang.ref.Cleaner;
  import java.lang.ref.Cleaner.Cleanable;
  import java.lang.ref.ReferenceQueue;
  import java.util.concurrent.ThreadFactory;
  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,115 ****
          // 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();
          }
  
          // 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.
--- 104,114 ----
          // 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 = 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,344 ****
          }
  
      }
  
      /**
-      * 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);
--- 308,317 ----