src/java.base/share/classes/java/lang/ref/Cleaner.java

@@ -23,14 +23,15 @@
  * questions.
  */
 
 package java.lang.ref;
 
+import jdk.internal.ref.CleanerImpl;
+
 import java.util.Objects;
 import java.util.concurrent.ThreadFactory;
-
-import jdk.internal.ref.CleanerImpl;
+import java.util.function.Function;
 
 /**
  * {@code Cleaner} manages a set of object references and corresponding cleaning actions.
  * <p>
  * Cleaning actions are {@link #register(Object object, Runnable action) registered}

@@ -133,11 +134,16 @@
      * The Cleaner implementation.
      */
     final CleanerImpl impl;
 
     static {
-        CleanerImpl.setCleanerImplAccess((Cleaner c) -> c.impl);
+        CleanerImpl.setCleanerImplAccess(new Function<Cleaner, CleanerImpl>() {
+            @Override
+            public CleanerImpl apply(Cleaner cleaner) {
+                return cleaner.impl;
+            }
+        });
     }
 
     /**
      * Construct a Cleaner implementation and start it.
      */

@@ -213,10 +219,36 @@
         Objects.requireNonNull(action, "action");
         return new CleanerImpl.PhantomCleanableRef(obj, this, action);
     }
 
     /**
+     * Helps cleaning thread by invoking next cleaning action registered by this
+     * Cleaner and for which GC has determined that the monitored object has become
+     * phantom reachable.
+     *
+     * @return {@code true} if a cleaning action was invoked by this method or
+     * {@code false} if there were no cleaning actions registered by this Cleaner
+     * for which GC would determine that their monitored objects are phantom reachable.
+     *
+     * @implNote Normally this method needs not be called as cleaning actions are
+     * executed by a background thread. But it is sometimes necessary to help the
+     * background thread with cleanup when it can not keep-up with the rate of
+     * registration of new cleaning actions and consequently the resource
+     * being cleaned-up may run-out. When this happens the resource allocation logic
+     * can re-try the allocation while helping with cleanup until this method
+     * returns false indicating that all pending cleaning actions have been invoked.
+     */
+    public boolean helpClean() {
+        while (!impl.cleanNextEnqueuedCleanable()) {
+            if (!Reference.tryHandlePending(false)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
      * {@code Cleanable} represents an object and a
      * cleaning action registered in a {@code Cleaner}.
      * @since 9
      */
     public interface Cleanable {