LeakPresenceDetector Class — netty Architecture

Source Code

common/src/main/java/io/netty/util/LeakPresenceDetector.java lines 83–361

public class LeakPresenceDetector<T> extends ResourceLeakDetector<T> {
    private static final String TRACK_CREATION_STACK_PROPERTY = "io.netty.util.LeakPresenceDetector.trackCreationStack";
    private static final boolean TRACK_CREATION_STACK =
            SystemPropertyUtil.getBoolean(TRACK_CREATION_STACK_PROPERTY, false);
    private static final ResourceScope GLOBAL = new ResourceScope("global");

    private static int staticInitializerCount;

    private static boolean inStaticInitializerSlow(StackTraceElement[] stackTrace) {
        for (StackTraceElement element : stackTrace) {
            if (element.getMethodName().equals("<clinit>")) {
                return true;
            }
        }
        return false;
    }

    private static boolean inStaticInitializerFast() {
        // This plain field access is safe. The worst that can happen is that we see non-zero where we shouldn't.
        return staticInitializerCount != 0 && inStaticInitializerSlow(Thread.currentThread().getStackTrace());
    }

    /**
     * Wrap a static initializer so that any resources created inside the block will not be tracked. Example:
     * <pre>{@code
     * private static final ByteBuf CRLF_BUF = LeakPresenceDetector.staticInitializer(() -> unreleasableBuffer(
     *             directBuffer(2).writeByte(CR).writeByte(LF)).asReadOnly());
     * }</pre>
     * <p>
     * Note that technically, this method does not actually care what happens inside the block. Instead, it turns on
     * stack trace introspection at the start of the block, and turns it back off at the end. Any allocation in that
     * interval will be checked to see whether it is part of a static initializer, and if it is, it will not be
     * tracked.
     *
     * @param supplier A code block to run
     * @return The value returned by the {@code supplier}
     * @param <R> The supplier return type
     */
    public static <R> R staticInitializer(Supplier<R> supplier) {
        if (!inStaticInitializerSlow(Thread.currentThread().getStackTrace())) {
            throw new IllegalStateException("Not in static initializer.");
        }
        synchronized (LeakPresenceDetector.class) {
            staticInitializerCount++;
        }
        try {
            return supplier.get();
        } finally {
            synchronized (LeakPresenceDetector.class) {
                staticInitializerCount--;
            }
        }
    }

    /**
     * Create a new detector for the given resource type.
     *
     * @param resourceType The resource type
     */
    public LeakPresenceDetector(Class<?> resourceType) {
        super(resourceType, 0);
    }

    /**
     * This constructor should not be used directly, it is called reflectively by {@link ResourceLeakDetectorFactory}.
     *
     * @param resourceType The resource type
     * @param samplingInterval Ignored
     */
    @Deprecated
    @SuppressWarnings("unused")
    public LeakPresenceDetector(Class<?> resourceType, int samplingInterval) {
        this(resourceType);
    }

    /**
     * This constructor should not be used directly, it is called reflectively by {@link ResourceLeakDetectorFactory}.
     *
     * @param resourceType The resource type
     * @param samplingInterval Ignored
     * @param maxActive Ignored