CleanerJava6 Class — netty Architecture

Source Code

common/src/main/java/io/netty/util/internal/CleanerJava6.java lines 36–166

final class CleanerJava6 implements Cleaner {
    private static final MethodHandle CLEAN_METHOD;

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(CleanerJava6.class);

    static {
        MethodHandle clean;
        Throwable error = null;
        final ByteBuffer direct = ByteBuffer.allocateDirect(1);
        try {
            Object mayBeCleanerField = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                @Override
                public Object run() {
                    try {
                        Class<?> cleanerClass = Class.forName("sun.misc.Cleaner");
                        Class<?> directBufClass = Class.forName("sun.nio.ch.DirectBuffer");
                        MethodHandles.Lookup lookup = MethodHandles.lookup();

                        // Call clean() on the cleaner
                        MethodHandle clean = lookup.findVirtual(
                                cleanerClass, "clean", methodType(void.class));
                        // But only if the cleaner is non-null
                        MethodHandle nullTest = lookup.findStatic(
                                Objects.class, "nonNull", methodType(boolean.class, Object.class));
                        clean = MethodHandles.guardWithTest(
                                nullTest.asType(methodType(boolean.class, cleanerClass)),
                                clean,
                                nullTest.asType(methodType(void.class, cleanerClass)));
                        // Change receiver to DirectBuffer, convert DirectBuffer to Cleaner by calling cleaner()
                        clean = MethodHandles.filterArguments(clean, 0, lookup.findVirtual(
                                directBufClass,
                                "cleaner",
                                methodType(cleanerClass)));
                        // Change receiver to ByteBuffer, convert using explicit cast to DirectBuffer
                        clean = MethodHandles.explicitCastArguments(clean,
                                methodType(void.class, ByteBuffer.class));
                        return clean;
                    } catch (Throwable cause) {
                        return cause;
                    }
                }
            });
            if (mayBeCleanerField instanceof Throwable) {
                throw (Throwable) mayBeCleanerField;
            }

            clean = (MethodHandle) mayBeCleanerField;
            clean.invokeExact(direct);
        } catch (Throwable t) {
            // We don't have ByteBuffer.cleaner().
            clean = null;
            error = t;
        }

        if (error == null) {
            logger.debug("java.nio.ByteBuffer.cleaner(): available");
        } else {
            logger.debug("java.nio.ByteBuffer.cleaner(): unavailable", error);
        }
        CLEAN_METHOD = clean;
    }

    static boolean isSupported() {
        return CLEAN_METHOD != null;
    }

    @Override
    public CleanableDirectBuffer allocate(int capacity) {
        return new CleanableDirectBufferImpl(ByteBuffer.allocateDirect(capacity));
    }

    @Deprecated
    @Override
    public void freeDirectBuffer(ByteBuffer buffer) {
        freeDirectBufferStatic(buffer);
    }

    private static void freeDirectBufferStatic(ByteBuffer buffer) {
        if (!buffer.isDirect()) {
            return;
        }