diff --git a/buffer/src/main/java/io/netty/buffer/AbstractByteBuf.java b/buffer/src/main/java/io/netty/buffer/AbstractByteBuf.java
index 9ce8ccc5a30e5fb7cfd5c3f751c30f1ee9d43969..6281eb11f22ddffd7ad74b06d333d8e6ef99d76a 100644
--- a/buffer/src/main/java/io/netty/buffer/AbstractByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/AbstractByteBuf.java
@@ -283,10 +283,15 @@ public abstract class AbstractByteBuf extends ByteBuf {
         return this;
     }
 
+    /**
+     * 确定可写容量+要写容量 < 最大容量
+     * @param minWritableBytes
+     */
     final void ensureWritable0(int minWritableBytes) {
         final int writerIndex = writerIndex();
         final int targetCapacity = writerIndex + minWritableBytes;
         if (targetCapacity <= capacity()) {
+            //检查buf释放情况，不抛出异常则正常返回
             ensureAccessible();
             return;
         }
@@ -1069,8 +1074,17 @@ public abstract class AbstractByteBuf extends ByteBuf {
         return this;
     }
 
+    /**
+     * 将byte数组写入到buf中
+     * @param src
+     * @param srcIndex the first index of the source
+     * @param length   the number of bytes to transfer
+     *
+     * @return
+     */
     @Override
     public ByteBuf writeBytes(byte[] src, int srcIndex, int length) {
+        //确定容量
         ensureWritable(length);
         setBytes(writerIndex, src, srcIndex, length);
         writerIndex += length;
@@ -1387,12 +1401,17 @@ public abstract class AbstractByteBuf extends ByteBuf {
         return ByteBufUtil.compare(this, that);
     }
 
+    /**
+     * 重写toString，如果引用计数=0，则表示将被释放
+     * 展示 readIndex，writeIndex，capacity容量
+     * @return
+     */
     @Override
     public String toString() {
         if (refCnt() == 0) {
             return StringUtil.simpleClassName(this) + "(freed)";
         }
-
+        // 返回相关容量信息
         StringBuilder buf = new StringBuilder()
             .append(StringUtil.simpleClassName(this))
             .append("(ridx: ").append(readerIndex)
@@ -1401,7 +1420,7 @@ public abstract class AbstractByteBuf extends ByteBuf {
         if (maxCapacity != Integer.MAX_VALUE) {
             buf.append('/').append(maxCapacity);
         }
-
+        //返回buf的根本类型
         ByteBuf unwrapped = unwrap();
         if (unwrapped != null) {
             buf.append(", unwrapped: ").append(unwrapped);
diff --git a/buffer/src/main/java/io/netty/buffer/ByteBuf.java b/buffer/src/main/java/io/netty/buffer/ByteBuf.java
index 850c85a21ef8d7e203b92d98d72573db8097d0dd..ea39d6e3a7740af9d05b83ce7987b61b9a627c2d 100644
--- a/buffer/src/main/java/io/netty/buffer/ByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/ByteBuf.java
@@ -17,6 +17,7 @@ package io.netty.buffer;
 
 import io.netty.util.ByteProcessor;
 import io.netty.util.ReferenceCounted;
+import sun.misc.Unsafe;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -2354,7 +2355,7 @@ public abstract class ByteBuf implements ReferenceCounted, Comparable<ByteBuf> {
 
     /**
      * Returns the backing byte array of this buffer.
-     *
+     * 堆内buf会返回数组对象，直接内存buf将抛出异常
      * @throws UnsupportedOperationException
      *         if there no accessible backing byte array
      */
diff --git a/common/src/main/java/io/netty/util/ReferenceCounted.java b/common/src/main/java/io/netty/util/ReferenceCounted.java
index 2e090cf5adf5865553752b8bee2194b4bff7a794..f348bec8804179c04f3361fa76be50202dc93ffc 100644
--- a/common/src/main/java/io/netty/util/ReferenceCounted.java
+++ b/common/src/main/java/io/netty/util/ReferenceCounted.java
@@ -31,11 +31,13 @@ package io.netty.util;
  */
 public interface ReferenceCounted {
     /**
+     * 返回对象的引用计数， 0=已经被释放了
      * Returns the reference count of this object.  If {@code 0}, it means this object has been deallocated.
      */
     int refCnt();
 
     /**
+     * 引用计数+1
      * Increases the reference count by {@code 1}.
      */
     ReferenceCounted retain();
diff --git a/transport/src/main/java/io/netty/bootstrap/ServerBootstrap.java b/transport/src/main/java/io/netty/bootstrap/ServerBootstrap.java
index 084c42fc6f98426b8c13148506cb16b5a6dcae9d..76e2a549a3b1459c9f3449085951b55f73f2ed8c 100644
--- a/transport/src/main/java/io/netty/bootstrap/ServerBootstrap.java
+++ b/transport/src/main/java/io/netty/bootstrap/ServerBootstrap.java
@@ -67,6 +67,7 @@ public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerCh
     }
 
     /**
+     * 指定evnetgroup为父和子事件选择器
      * Specify the {@link EventLoopGroup} which is used for the parent (acceptor) and the child (client).
      */
     @Override
@@ -75,6 +76,7 @@ public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerCh
     }
 
     /**
+     * 设置父 和子事件选择器，这些选择器用来处理所有 事件、 serverchannel和channel的IO事件
      * Set the {@link EventLoopGroup} for the parent (acceptor) and the child (client). These
      * {@link EventLoopGroup}'s are used to handle all the events and IO for {@link ServerChannel} and
      * {@link Channel}'s.
@@ -89,6 +91,7 @@ public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerCh
     }
 
     /**
+     * 为channel的 option map 指定一个 channelOption，如果 value = null，则移除这个 channelOption
      * Allow to specify a {@link ChannelOption} which is used for the {@link Channel} instances once they get created
      * (after the acceptor accepted the {@link Channel}). Use a value of {@code null} to remove a previous set
      * {@link ChannelOption}.
@@ -106,6 +109,7 @@ public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerCh
     }
 
     /**
+     * 设置一个指定 attributekey ，如果为null 则移除这个key
      * Set the specific {@link AttributeKey} with the given value on every child {@link Channel}. If the value is
      * {@code null} the {@link AttributeKey} is removed
      */
@@ -120,6 +124,7 @@ public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerCh
     }
 
     /**
+     * 设置 用于处理 channel request 的 channelHandler
      * Set the {@link ChannelHandler} which is used to serve the request for the {@link Channel}'s.
      */
     public ServerBootstrap childHandler(ChannelHandler childHandler) {
diff --git a/transport/src/main/java/io/netty/channel/Channel.java b/transport/src/main/java/io/netty/channel/Channel.java
index 6acb59d3b31cabb8383f9213230f96d142b9235a..8132f799fb533919b63b786d8f563244d01198b2 100644
--- a/transport/src/main/java/io/netty/channel/Channel.java
+++ b/transport/src/main/java/io/netty/channel/Channel.java
@@ -78,48 +78,56 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
 
     /**
      * Returns the globally unique identifier of this {@link Channel}.
+     * 返回全局唯一的channelId对象,
      */
     ChannelId id();
 
     /**
      * Return the {@link EventLoop} this {@link Channel} was registered to.
+     *  返回channel被注册于哪个eventloop
      */
     EventLoop eventLoop();
 
     /**
      * Returns the parent of this channel.
-     *
+     *返回父channel，如果没有则为null
      * @return the parent channel.
      *         {@code null} if this channel does not have a parent channel.
      */
     Channel parent();
 
     /**
+     * 返回配置
      * Returns the configuration of this channel.
      */
     ChannelConfig config();
 
     /**
+     * 返回channel是否open状态，稍后将处于活跃状态
      * Returns {@code true} if the {@link Channel} is open and may get active later
      */
     boolean isOpen();
 
     /**
+     * 返回是否已注册到eventloop
      * Returns {@code true} if the {@link Channel} is registered with an {@link EventLoop}.
      */
     boolean isRegistered();
 
     /**
+     * channel如果处于活跃状态，因此肯定是已连接（的状态）
      * Return {@code true} if the {@link Channel} is active and so connected.
      */
     boolean isActive();
 
     /**
+     * 返回channel的元数据
      * Return the {@link ChannelMetadata} of the {@link Channel} which describe the nature of the {@link Channel}.
      */
     ChannelMetadata metadata();
 
     /**
+     * 返回channel绑定的本地地址
      * Returns the local address where this channel is bound to.  The returned
      * {@link SocketAddress} is supposed to be down-cast into more concrete
      * type such as {@link InetSocketAddress} to retrieve the detailed
@@ -131,6 +139,7 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
     SocketAddress localAddress();
 
     /**
+     * 返回channle所连接的对方地址，如果连接关闭，则返回null，一些不借助不用连接连也可以传输数据的情况下，也返回null，比如 udp协议
      * Returns the remote address where this channel is connected to.  The
      * returned {@link SocketAddress} is supposed to be down-cast into more
      * concrete type such as {@link InetSocketAddress} to retrieve the detailed
@@ -147,12 +156,14 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
     SocketAddress remoteAddress();
 
     /**
+     * 返回channel关闭时将会被通知的futrue对象
      * Returns the {@link ChannelFuture} which will be notified when this
      * channel is closed.  This method always returns the same future instance.
      */
     ChannelFuture closeFuture();
 
     /**
+     * 当且仅当io线程可以立即执行写操作时，返回ture。当返回false时，所有的写操作都会进入队列，直到io线程又开始处理写操作时。
      * Returns {@code true} if and only if the I/O thread will perform the
      * requested write operation immediately.  Any write requests made when
      * this method returns {@code false} are queued until the I/O thread is
@@ -161,6 +172,7 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
     boolean isWritable();
 
     /**
+     * 当 isWritable()返回false时，返回可以写入多少个bytes。
      * Get how many bytes can be written until {@link #isWritable()} returns {@code false}.
      * This quantity will always be non-negative. If {@link #isWritable()} is {@code false} then 0.
      */
@@ -209,6 +221,7 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
     interface Unsafe {
 
         /**
+         * 返回，RecvByteBufAllocator对象，这个对象用来接受到数据后分配bytebuf
          * Return the assigned {@link RecvByteBufAllocator.Handle} which will be used to allocate {@link ByteBuf}'s when
          * receiving data.
          */
@@ -227,18 +240,23 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
         SocketAddress remoteAddress();
 
         /**
+         * 将 channelPromise中的channel注册到evnetloop上，并在注册完成后通知 channelFuture（promise是futrue的子类）。
          * Register the {@link Channel} of the {@link ChannelPromise} and notify
          * the {@link ChannelFuture} once the registration was complete.
          */
         void register(EventLoop eventLoop, ChannelPromise promise);
 
         /**
+         * 将socketaddress绑定到channel上，并在完成后通知promise
          * Bind the {@link SocketAddress} to the {@link Channel} of the {@link ChannelPromise} and notify
          * it once its done.
          */
         void bind(SocketAddress localAddress, ChannelPromise promise);
 
         /**
+         * 将入参 对方地址和给定的 promise中的channel连接起来，并和特定的本地socket地址绑定，不指定本地socket地址的话，
+         * localAddress可以传null
+         * 连接操作完成后，会通知promise
          * Connect the {@link Channel} of the given {@link ChannelFuture} with the given remote {@link SocketAddress}.
          * If a specific local {@link SocketAddress} should be used it need to be given as argument. Otherwise just
          * pass {@code null} to it.
@@ -248,46 +266,55 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
         void connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise);
 
         /**
+         * 断开连接，并在完成后通知promise
          * Disconnect the {@link Channel} of the {@link ChannelFuture} and notify the {@link ChannelPromise} once the
          * operation was complete.
          */
         void disconnect(ChannelPromise promise);
 
         /**
+         * 关闭channel，并通知promise
          * Close the {@link Channel} of the {@link ChannelPromise} and notify the {@link ChannelPromise} once the
          * operation was complete.
          */
         void close(ChannelPromise promise);
 
         /**
+         * 强制关闭channel，且不触发任意事件，一般用于注册失败的时候
          * Closes the {@link Channel} immediately without firing any events.  Probably only useful
          * when registration attempt failed.
          */
         void closeForcibly();
 
         /**
+         * 从eventloop中取消注册channel，并通知promise
          * Deregister the {@link Channel} of the {@link ChannelPromise} from {@link EventLoop} and notify the
          * {@link ChannelPromise} once the operation was complete.
          */
         void deregister(ChannelPromise promise);
 
         /**
-         * Schedules a read operation that fills the inbound buffer of the first {@link ChannelInboundHandler} in the
+         * 准备一次读操作，该读操作会把管道中第一个ChannelInboundHandler的 inbound buffer 缓冲块填满，如果已有读操作了，这个方法将不会生效
+         * Schedules安排，预定 a read operation that fills the inbound buffer of the first {@link ChannelInboundHandler} in the
          * {@link ChannelPipeline}.  If there's already a pending read operation, this method does nothing.
          */
         void beginRead();
 
         /**
+         * 计划一次写操作
          * Schedules a write operation.
          */
         void write(Object msg, ChannelPromise promise);
 
         /**
+         * 对所有写操作执行flush
          * Flush out all write operations scheduled via {@link #write(Object, ChannelPromise)}.
          */
         void flush();
 
         /**
+         * 返回一个特殊的promise对象，并且可以在unsafe的操作中重复使用和传递。这个特殊的promise
+         * 仅仅作为操作的载体，但不接收任何成功或失败的通知
          * Return a special ChannelPromise which can be reused and passed to the operations in {@link Unsafe}.
          * It will never be notified of a success or error and so is only a placeholder for operations
          * that take a {@link ChannelPromise} as argument but for which you not want to get notified.
@@ -295,6 +322,7 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparabl
         ChannelPromise voidPromise();
 
         /**
+         * 返回即将发生写操作的channel中的ChannelOutboundBuffer
          * Returns the {@link ChannelOutboundBuffer} of the {@link Channel} where the pending write requests are stored.
          */
         ChannelOutboundBuffer outboundBuffer();
diff --git a/transport/src/main/java/io/netty/channel/ChannelHandler.java b/transport/src/main/java/io/netty/channel/ChannelHandler.java
index 3879056e43cc1abe587e6bbb13284746ce123c69..79436e4e993f3d263d9cc756641fff7ddf9cbae1 100644
--- a/transport/src/main/java/io/netty/channel/ChannelHandler.java
+++ b/transport/src/main/java/io/netty/channel/ChannelHandler.java
@@ -26,6 +26,7 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
+ * 处理所有 IO事件或IO拦截事件，并会传递到下一个管道中的handler。
  * Handles an I/O event or intercepts an I/O operation, and forwards it to its next handler in
  * its {@link ChannelPipeline}.
  *
@@ -178,11 +179,13 @@ import java.lang.annotation.Target;
 public interface ChannelHandler {
 
     /**
+     * 当handler被添加到 channel handler ctx中，且handler可以处理事件后，这个方法会被调用
      * Gets called after the {@link ChannelHandler} was added to the actual context and it's ready to handle events.
      */
     void handlerAdded(ChannelHandlerContext ctx) throws Exception;
 
     /**
+     * 当handler被移除后，且不再处理任何事件后，这个方法会被调用
      * Gets called after the {@link ChannelHandler} was removed from the actual context and it doesn't handle events
      * anymore.
      */
diff --git a/transport/src/main/java/io/netty/channel/ChannelHandlerAdapter.java b/transport/src/main/java/io/netty/channel/ChannelHandlerAdapter.java
index 2041ebd12b8e73892e57341607b494c9f6e8274e..ad73aa92dc94a8fb7568a95a50f5faa26afa6484 100644
--- a/transport/src/main/java/io/netty/channel/ChannelHandlerAdapter.java
+++ b/transport/src/main/java/io/netty/channel/ChannelHandlerAdapter.java
@@ -22,6 +22,7 @@ import io.netty.util.internal.InternalThreadLocalMap;
 import java.util.Map;
 
 /**
+ * ChannelHandler的概要实现类
  * Skeleton implementation of a {@link ChannelHandler}.
  */
 public abstract class ChannelHandlerAdapter implements ChannelHandler {
diff --git a/transport/src/main/java/io/netty/channel/ChannelHandlerContext.java b/transport/src/main/java/io/netty/channel/ChannelHandlerContext.java
index cb12cfc2b4e2d5472023eacf449604d74e0e79b1..53331bc0c27d247dca1054b4b3aff061ec4c5f08 100644
--- a/transport/src/main/java/io/netty/channel/ChannelHandlerContext.java
+++ b/transport/src/main/java/io/netty/channel/ChannelHandlerContext.java
@@ -25,6 +25,11 @@ import io.netty.util.concurrent.EventExecutor;
 import java.nio.channels.Channels;
 
 /**
+ * 这个接口集成了 attrimap，outbond，inbound，并新增了很多方法，这些方法都是用来获取 channel，executor，handler，pipline，
+ * allocator元素的方法，可以认为这个接口是一个 ctx上下文接口。
+ *
+ * 使 handler 和管道  和其他 handler 能互相影响，同时能通知下一个 handler当 管道发生变化时
+ *
  * Enables a {@link ChannelHandler} to interact with its {@link ChannelPipeline}
  * and other handlers. Among other things a handler can notify the next {@link ChannelHandler} in the
  * {@link ChannelPipeline} as well as modify the {@link ChannelPipeline} it belongs to dynamically.
diff --git a/transport/src/main/java/io/netty/channel/ChannelInboundHandler.java b/transport/src/main/java/io/netty/channel/ChannelInboundHandler.java
index ae3a5040917461d600e7a93eb02e4f744d51cd5f..fe398873141ceb14fce44f7f99b957b8e5cabc50 100644
--- a/transport/src/main/java/io/netty/channel/ChannelInboundHandler.java
+++ b/transport/src/main/java/io/netty/channel/ChannelInboundHandler.java
@@ -16,38 +16,45 @@
 package io.netty.channel;
 
 /**
+ * 加入了channel 状态变更回调的 channelHandler，这些回调允许用户能轻松对channel 状态变更挂钩
  * {@link ChannelHandler} which adds callbacks for state changes. This allows the user
  * to hook in to state changes easily.
  */
 public interface ChannelInboundHandler extends ChannelHandler {
 
     /**
+     * chctx中的 channle被注册到 channel中的eventloop中
      * The {@link Channel} of the {@link ChannelHandlerContext} was registered with its {@link EventLoop}
      */
     void channelRegistered(ChannelHandlerContext ctx) throws Exception;
 
     /**
+     * chctx中的channle取消注册
      * The {@link Channel} of the {@link ChannelHandlerContext} was unregistered from its {@link EventLoop}
      */
     void channelUnregistered(ChannelHandlerContext ctx) throws Exception;
 
     /**
+     * channel 变更为活跃状态
      * The {@link Channel} of the {@link ChannelHandlerContext} is now active
      */
     void channelActive(ChannelHandlerContext ctx) throws Exception;
 
     /**
+     * 已注册的channel 变为非活跃，并达到生命周期的结束
      * The {@link Channel} of the {@link ChannelHandlerContext} was registered is now inactive and reached its
      * end of lifetime.
      */
     void channelInactive(ChannelHandlerContext ctx) throws Exception;
 
     /**
+     * 当channel 从peer中读到一条消息后，会被执行 channelread
      * Invoked when the current {@link Channel} has read a message from the peer.
      */
     void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception;
 
     /**
+     * 当最后一条消息被读取后，这个方法被执行
      * Invoked when the last message read by the current read operation has been consumed by
      * {@link #channelRead(ChannelHandlerContext, Object)}.  If {@link ChannelOption#AUTO_READ} is off, no further
      * attempt to read an inbound data from the current {@link Channel} will be made until
@@ -56,17 +63,20 @@ public interface ChannelInboundHandler extends ChannelHandler {
     void channelReadComplete(ChannelHandlerContext ctx) throws Exception;
 
     /**
+     * 当用户时间被触发，这个方法会被执行
      * Gets called if an user event was triggered.
      */
     void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception;
 
     /**
+     * channel 可写状态发生变化时，被执行
      * Gets called once the writable state of a {@link Channel} changed. You can check the state with
      * {@link Channel#isWritable()}.
      */
     void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception;
 
     /**
+     * 当异常被抛出时，该方法被执行
      * Gets called if a {@link Throwable} was thrown.
      */
     @Override
diff --git a/transport/src/main/java/io/netty/channel/ChannelInboundHandlerAdapter.java b/transport/src/main/java/io/netty/channel/ChannelInboundHandlerAdapter.java
index f9a88842afc7c3bc09b9848094ccca1725a3d8bc..3c36ac0381a4d71f78ac78593ffa663923d54e0e 100644
--- a/transport/src/main/java/io/netty/channel/ChannelInboundHandlerAdapter.java
+++ b/transport/src/main/java/io/netty/channel/ChannelInboundHandlerAdapter.java
@@ -18,6 +18,7 @@ package io.netty.channel;
 import io.netty.channel.ChannelHandlerMask.Skip;
 
 /**
+ * ChannelInboundHandler 的基本实现类
  * Abstract base class for {@link ChannelInboundHandler} implementations which provide
  * implementations of all of their methods.
  *