--- old/src/java.base/share/classes/jdk/internal/ref/CleanerFactory.java	2016-04-01 16:47:27.434826920 +0200
+++ new/src/java.base/share/classes/jdk/internal/ref/CleanerFactory.java	2016-04-01 16:47:27.339826317 +0200
@@ -26,6 +26,7 @@
 package jdk.internal.ref;
 
 import jdk.internal.misc.InnocuousThread;
+import jdk.internal.vm.annotation.ReservedStackAccess;
 
 import java.lang.ref.Cleaner;
 import java.security.AccessController;
@@ -38,24 +39,43 @@
  */
 public final class CleanerFactory {
 
-    /* The common Cleaner. */
-    private final static Cleaner commonCleaner = Cleaner.create(new ThreadFactory() {
-        @Override
-        public Thread newThread(Runnable r) {
-            return AccessController.doPrivileged(new PrivilegedAction<>() {
-                @Override
-                public Thread run() {
-                    Thread t = InnocuousThread.newSystemThread("Common-Cleaner", r);
-                    t.setPriority(Thread.MAX_PRIORITY - 2);
-                    return t;
-                }
-            });
-        }
-    });
+    /* The common Cleaner. Lazily initialized */
+    private static class Common {
+        static final Cleaner INSTANCE = Cleaner.create(new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                return AccessController.doPrivileged(new PrivilegedAction<>() {
+                    @Override
+                    public Thread run() {
+                        Thread t = InnocuousThread.newSystemThread("Common-Cleaner", r);
+                        t.setPriority(Thread.MAX_PRIORITY - 2);
+                        return t;
+                    }
+                });
+            }
+        });
+    }
+
+    /* The NIO DirectByteBuffer ExtendedCleaner. Lazily initialized */
+    private static class DBB {
+        static final ExtendedCleaner INSTANCE = ExtendedCleaner.create(new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                return AccessController.doPrivileged(new PrivilegedAction<>() {
+                    @Override
+                    public Thread run() {
+                        Thread t = InnocuousThread.newSystemThread("DirectByteBuffer-Cleaner", r);
+                        t.setPriority(Thread.MAX_PRIORITY - 2);
+                        return t;
+                    }
+                });
+            }
+        });
+    }
 
     /**
      * Cleaner for use within system modules.
-     *
+     * <p>
      * This Cleaner will run on a thread whose context class loader
      * is {@code null}. The system cleaning action to perform in
      * this Cleaner should handle a {@code null} context class loader.
@@ -63,6 +83,23 @@
      * @return a Cleaner for use within system modules
      */
     public static Cleaner cleaner() {
-        return commonCleaner;
+        return Common.INSTANCE;
+    }
+
+    /**
+     * ExtendedCleaner for DirectByteBuffer use.
+     * <p>
+     * This Cleaner will mostly run on a background thread whose
+     * context class loader is {@code null}. But since this is
+     * {@link ExtendedCleaner} it allows other threads to help executing
+     * cleaning actions. Cleaning actions to be performed in this ExtendedCleaner
+     * should handle a {@code null} context class loader and any application
+     * thread. When they are executed by an application thread they are
+     * executed in the context of {@link ReservedStackAccess} annotation.
+     *
+     * @return an ExtendedCleaner for use in DirectByteBuffer
+     */
+    public static ExtendedCleaner dbbCleaner() {
+        return DBB.INSTANCE;
     }
 }