Source code
package io.netty.channel;
import io.netty.util.internal.ThrowableUtil;
import io.netty.util.internal.UnstableApi;
import java.nio.channels.ClosedChannelException;
/**
* Cheap {@link ClosedChannelException} that does not fill in the stacktrace.
*/
@UnstableApi
public final class StacklessClosedChannelException extends ClosedChannelException {
private static final long serialVersionUID = -2214806025529435136L;
private StacklessClosedChannelException() { }
@Override
public Throwable fillInStackTrace() {
// Suppress a warning since this method doesn't need synchronization
return this;
}
/**
* Creates a new {@link StacklessClosedChannelException} which has the origin of the given {@link Class} and method.
*/
public static StacklessClosedChannelException newInstance(Class<?> clazz, String method) {
return ThrowableUtil.unknownStackTrace(new StacklessClosedChannelException(), clazz, method);
}
}
Run 1
The code is highly readable. Structure is logical: package, imports, class, field, constructor, override, factory method. Nesting is minimal—only one method override and one static factory, both flat. Intent is clear: a performance-optimized exception that skips stacktrace generation, with Javadoc explaining purpose. Length is concise and appropriate for the functionality. Action granularity is one action per line. Reading flow is natural, moving from class definition to constructor to behavior override to factory method. Minor deductions: the suppressed warning comment could be slightly more specific, and the class could be final (already is). Overall, excellent clarity and simplicity.
Run 2
The code is highly readable with clear structure: imports, class declaration, a private constructor, an overridden method, and a factory method. Nesting is minimal and natural. Intent is well-documented with Javadoc, explaining both the class purpose and the factory method. Code length is concise, with no redundant lines. Each line performs a single action, and the reading flow follows a logical top-to-bottom progression. Minor deductions: the @Override method could have a small comment clarifying why it returns 'this' (though it is evident from the class description), and the factory method's parameters could have slightly more descriptive names (e.g., 'clazz' vs 'sourceClass').
Run 3
The code is well-structured, concise, and clearly purposeful. It follows standard Java class organization with imports, class declaration, private constructor, overridden method, and a static factory method. Nesting is minimal, and each statement is on its own line, making the flow easy to follow. The class name and comments clearly communicate intent—avoiding stacktrace generation for performance. The only minor deduction is because the override of fillInStackTrace uses a comment that could be more specific, but overall the code is highly readable.
Run 1
Code Structure: Logically organized into a serialization field, private constructor, overridden method, and factory method. Nesting: Flat, with no nested control flow. Clarity of intent: The class name, documentation, and override clearly communicate stack-trace suppression; the factory documents its origin metadata. Code length: Concise, with minimal boilerplate and no unnecessary logic. Action granularity: Each statement performs one clear action; the factory's composed expression remains easy to understand. Reading flow: Natural progression from class purpose to implementation and construction. Minor drawbacks are the lack of spacing between the package and imports and the need to inspect ThrowableUtil.unknownStackTrace to understand exactly how origin metadata is represented.
Run 2
Code Structure: The class is logically organized into a constant, constructor, overridden method, and factory method. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: The class name, documentation, and fillInStackTrace override clearly convey the purpose of a lightweight exception; the factory documents its origin metadata. Code length: The implementation is concise without unnecessary abstractions. Action granularity: Each statement performs one clear action, although the factory combines construction and stack-trace customization in one easily understood expression. Reading flow: The ordering is natural and consistent. Minor drawbacks are the lack of spacing between the package and imports and the slightly ambiguous synchronization-warning comment.
Run 3
Code Structure: The class is logically organized into a constant, private constructor, overridden method, and factory method. Nesting: Methods are flat, with no conditional or loop nesting. Clarity of intent: The class name, documentation, and fillInStackTrace override clearly communicate the stackless exception behavior; the factory's reliance on unknownStackTrace requires minor external context. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs a single clear action, although the factory combines construction and stack-trace customization in one expression. Reading flow: The declaration-to-factory progression is natural. Minor formatting improvements, such as separating the package declaration from imports, would improve visual readability.