More javadoc fixes

transport/src/main/java/io/netty/channel/ChannelDuplexHandler.java

@@ -84,16 +84,34 @@ public class ChannelDuplexHandler extends ChannelInboundHandlerAdapter implement
         ctx.deregister(future);
     }
 
+    /**
+     * Calls {@link ChannelHandlerContext#read()} to forward
+     * to the next {@link ChannelOutboundHandler} in the {@link ChannelPipeline}.
+     *
+     * Sub-classes may override this method to change behavior.
+     */
     @Override
     public void read(ChannelHandlerContext ctx) throws Exception {
         ctx.read();
     }
 
+    /**
+     * Calls {@link ChannelHandlerContext#write(Object, ChannelPromise)} to forward
+     * to the next {@link ChannelOutboundHandler} in the {@link ChannelPipeline}.
+     *
+     * Sub-classes may override this method to change behavior.
+     */
     @Override
     public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
         ctx.write(msg, promise);
     }
 
+    /**
+     * Calls {@link ChannelHandlerContext#flush()} to forward
+     * to the next {@link ChannelOutboundHandler} in the {@link ChannelPipeline}.
+     *
+     * Sub-classes may override this method to change behavior.
+     */
     @Override
     public void flush(ChannelHandlerContext ctx) throws Exception {
         ctx.flush();

transport/src/main/java/io/netty/channel/ChannelPromiseAggregator.java

@@ -31,6 +31,12 @@ public final class ChannelPromiseAggregator implements ChannelFutureListener {
 
     private Set<ChannelPromise> pendingPromises;
 
+
+    /**
+     * Instance an new {@link ChannelPromiseAggregator}
+     *
+     * @param aggregatePromise  the {@link ChannelPromise} to notify
+     */
     public ChannelPromiseAggregator(ChannelPromise aggregatePromise) {
         if (aggregatePromise == null) {
             throw new NullPointerException("aggregatePromise");

transport/src/main/java/io/netty/channel/ChannelPromiseNotifier.java

@@ -22,6 +22,11 @@ public final class ChannelPromiseNotifier implements ChannelFutureListener {
 
     private final ChannelPromise[] promises;
 
+    /**
+     * Create a new instance
+     *
+     * @param promises  the {@link ChannelPromise}s to notify once this {@link ChannelFutureListener} is notified.
+     */
     public ChannelPromiseNotifier(ChannelPromise... promises) {
         if (promises == null) {
             throw new NullPointerException("promises");

transport/src/main/java/io/netty/channel/MultithreadEventLoopGroup.java

@@ -42,6 +42,9 @@ public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutor
         }
     }
 
+    /**
+     * @see {@link MultithreadEventExecutorGroup#MultithreadEventExecutorGroup(int, ThreadFactory, Object...)}
+     */
     protected MultithreadEventLoopGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
         super(nThreads == 0? DEFAULT_EVENT_LOOP_THREADS : nThreads, threadFactory, args);
     }

transport/src/main/java/io/netty/channel/embedded/EmbeddedChannel.java

@@ -243,6 +243,9 @@ public class EmbeddedChannel extends AbstractChannel {
         PlatformDependent.throwException(t);
     }
 
+    /**
+     * Ensure the {@link Channel} is open and of not throw an exception.
+     */
     protected final void ensureOpen() {
         if (!isOpen()) {
             recordException(new ClosedChannelException());