netty名词

2020-06-25

字数统计: 17.4k字 | 阅读时长≈ 77分

名词

netty的channel

a component which is capable of I/O operations such as read, write, connect, and bind.

这就是说该channel是一个具有IO操作（读，写，连接，绑定）能力的组件

一个channel的创建会对应把 pipeline对象创建出来，和unsafe对象(IO操作实际干活逻辑)创建出来

Channel  实现 AttributeMap和 Comparable<Channel> 
    AttributeMap 他的能力 持有一个可以通过AttributeKey来获取Attribute，并且子类对接口AttributeMap的实现是线程安全的
    Comparable这个就是带有比较的能力
    /*
	提供：
	       当前channel的状态  是打开，还是已连接状态。
	       ChannelConfig来配置参数，例如 buffer的大小
	       ChannelPipeline来处理所有的IO事件和channel相关的请求
	       
   所有IO操作都是异步：
           任何IO调用会立即返回，但是不保证IO操作完成（只是调用IO，IO执行还没有完成），此时会返回一个ChannelFuture实例，当请求IO操作成功，失败或者取消时 将会通知ChannelFuture实例，意思就是可以从ChannelFuture里面获取IO操作执行的状态
           
    Channels是有层次关系的：
            创建的时候可以决定一个Channel可以有一个父亲级别的Channel，例如SocketChannel被一个ServerSocketChannel接待（accept），那么SocketChannel实例被创建时他的parent就是ServerSocketChannel实例，
            层次结构的语义取决于Channel所属的传输实现。例如，您可以编写一个新的Channel实现，该实现创建共享一个socket连接的子通道
          
    向下转换类型以访问特定于传输的操作：
            某些传输公开特定于传输的附加操作。将{@link Channel}向下转换为子类型以调用此类操作。例如，对于旧的I/O数据报传输，多播 join/leave 操作由{@link DatagramChannel}提供。
         
    释放资源 :
            使用完{@link Channel}后，调用{@link#close（）或{@link#close（ChannelPromise）}释放所有资源（非常重要）。这样可以确保以正确的方式释放所有资源。
  */
   
         内部接口Unsafe：从用户代码永远都不应该调用不安全的操作。提供这些方法只是为了实现实际传输，并且必须从I/O线程调用，但以下方法除外：#localAddress()，#remoteAddress()，#closeForcibly()，#register(EventLoop, ChannelPromise)，#voidPromise()
             



DuplexChannel 继承 Channel
    具备双工能力的Channel，就是读的同时可以写
        boolean isInputShutdown();
        boolean isOutputShutdown();
        ChannelFuture shutdownOutput();
        ChannelFuture shutdownOutput(ChannelPromise promise);


SocketChannel 继承 DuplexChannel 
    一个tcp /IP的socket channel   
   

ServerChannel 继承   Channel
    一个标记接口，代表可以接待客户端的连接

ServerSocketChannel 继承 ServerChannel
     一个接待tcp/ip连接的ServerChannel

netty的ChannelMetadata

Represents the properties of a {@link Channel} implementation.

代表一个channel子类实现需要的属性(一些元数据信息)

 public ChannelMetadata(boolean hasDisconnect) {
        this.hasDisconnect = hasDisconnect;
    }    
hasDisconnect 为true时 ，如果 且仅当channel具有{@code disconnect（）}操作，该操作才允许用户断开连接，然后再次调用{@link channel#connect（SocketAddress）}

netty的ChannelConfig

A set of configuration properties of a {@link Channel}.

就是channel 的配置属性的集合，作用就是可以通过它来定制化你的Channel

ChannelConfig
    /*
    请强制转换为更特定的配置类型，如{@link SocketChannelConfig}，或使用#setOptions（Map）方法设置特定传输属性：
        Channel ch = ...;
        SocketChannelConfig cfg = (SocketChannelConfig) ch.getConfig();    
        cfg.setTcpNoDelay(false);
    选项映射
        一个选项的映射属性是一个动态的只写属性，它允许配置一个{@link Channel}，而不需要向下转换关联{@link ChannelConfig}的类型。要更新一个选项的映射，请调用{@link setOptions（map）}。
        所有的{@link ChannelConfig} 都有以下的选项：
             名称                相关的setter方法
 ChannelOption#CONNECT_TIMEOUT_MILLIS      #setConnectTimeoutMillis(int)
 ChannelOption#WRITE_SPIN_COUNT            #setWriteSpinCount(int)
 ChannelOption#ALLOCATOR                   #setAllocator(ByteBufAllocator)
 ChannelOption#AUTO_READ                   #setAutoRead(boolean)
     
      {@link ChannelConfig}的子类型中提供了更多选项。例如，您可以配置特定于TCP/IP套接字的参数，如{@link SocketChannelConfig}中所述
    */


SocketChannelConfig
    /*
    A {@link ChannelConfig} for a {@link SocketChannel}.
    为SocketChannel专门准备的一个配置接口
    SocketChannelConfig除了拥有{@link ChannelConfig}所有选项外，还必须具备以下的选项：
                    名称                相关的setter方法
       ChannelOption#SO_KEEPALIVE      #setKeepAlive(boolean)     
       ChannelOption#SO_REUSEADDR      #setReuseAddress(boolean)
       ChannelOption#SO_LINGER         #setSoLinger(int)
       ChannelOption#TCP_NODELAY       #setTcpNoDelay(boolean)
       ChannelOption#SO_RCVBUF         #setReceiveBufferSize(int)
       ChannelOption#SO_SNDBUF         #setSendBufferSize(int)
       ChannelOption#IP_TOS            #setTrafficClass(int)
      ChannelOption#ALLOW_HALF_CLOSURE #setAllowHalfClosure(boolean)
    */

netty的ChannelFuture

The result of an asynchronous {@link Channel} I/O operation.

异步{@link Channel}I/O操作的结果。

java.util.concurrent.Future<V>
/*
{@code Future}表示异步计算的结果。提供了检查计算是否完成、等待计算完成以及检索计算结果的方法。计算完成后，只能使用{@code get}方法检索结果，如果需要，则阻塞直到结果就绪。取消操作由{@code cancel}方法执行。提供了其他方法来确定任务是正常完成还是被取消。一旦计算完成，就不能取消计算。如果使用{@code Future}是因为它有可取消的能力，但不提供可用的结果，则可以声明{@code Future<shi？>}并返回{@code null}作为底层任务的结果。
   下面是一个简单的示例
 * <pre> {@code
 * interface ArchiveSearcher { String search(String target); }
 * class App {
 *   ExecutorService executor = ...
 *   ArchiveSearcher searcher = ...
 *   void showSearch(String target) throws InterruptedException {
 *     Callable<String> task = () -> searcher.search(target);
 *     Future<String> future = executor.submit(task);
 *     displayOtherThings(); // do other things while searching
 *     try {
 *       displayText(future.get()); // use future
 *     } catch (ExecutionException ex) { cleanup(); return; }
 *   }
 * }}</pre>
 
{@linkfuturetask}类是实现了 {@code Runnable}和{@code Future}，因此可以由{@code Executor}执行。例如，上面的{@code submit}结构可以替换为：

 * {FutureTask<String> future = new FutureTask<>(task);
 * executor.execute(future);}
 
 内存一致性效果：异步计算采取的操作发生在另一线程中，对应再调用{@code Future.get()}方法之后的操作之前。
*/
     api：
        boolean cancel(boolean mayInterruptIfRunning);//试图取消此任务的执行。如果任务已完成、已取消或由于其他原因无法取消，则此尝试将失败，返回false。如果成功，并且在调用{@code cancel}时此任务尚未启动，则此任务不应运行。如果任务已经启动，则{@code mayinteruptingfrunning}参数确定是否应中断执行此任务的线程以尝试停止该任务。此方法返回后，对{@link#isDone}的后续调用将始终返回{@code true}。如果此方法返回{@code true}，则对{@link#isCancelled}的后续调用将始终返回{@code true}。
        boolean isCancelled();//自己猜
        boolean isDone();//自己猜
        V get() throws InterruptedException, ExecutionException;//如果任务没有执行完成，需阻塞等待结果
        V get(long timeout, TimeUnit unit)//自己猜
        throws InterruptedException, ExecutionException, TimeoutException;




Future<V>   继承 java.util.concurrent.Future<V>
   有获取异步操作的结果的能力。
    api：
       boolean isSuccess();仅当I/O操作成功完成时返回{@code true}。
	   boolean isCancellable();返回true如果并且仅当可以通过{@link#cancel（boolean）}取消操作时。
	   Throwable cause();如果I/O操作失败，则返回失败的I/O操作的原因。
       Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);//将指定的Listener添加到此Future。当Future动作{@linkplain#isDone（）为true}完成时，将通知指定的Listener。如果此Future已完成，则会立即通知指定的Listener。
       Future<V> addListeners(GenericFutureListener<? extends Future<? super V>>... listeners);
       Future<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener);
       Future<V> removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners);
       Future<V> sync() throws InterruptedException;//关键方法，同步阻塞等待这个Future的isDone为true，可以使用线程中断来唤醒，不过必须手动捕捉中断异常，还会抛出失败运行时异常
       Future<V> syncUninterruptibly();//阻塞等待这个Future的isDone为true，可以使用线程中断来唤醒，不需要手动捕捉中断异常，还会抛出失败运行时异常，这个需要捕捉
       Future<V> await() throws InterruptedException;//一直等，直到完成，可以使用线程中断来唤醒，不过必须手动捕捉异常
       Future<V> awaitUninterruptibly();//一直等，直到完成，可以使用线程中断来唤醒，不需要手动捕捉

       boolean await(long timeoutMillis) throws InterruptedException;//这个future再指定时间内完成返回true，没有完成返回false，可以使用线程中断来唤醒，不过必须手动捕捉异常
       boolean await(long timeout, TimeUnit unit) throws InterruptedException;//加了个单位
       
       boolean awaitUninterruptibly(long timeoutMillis);//该方法与await(long timeoutMillis)的区别就是内部会捕捉到InterruptedException异常，然后丢调
       boolean awaitUninterruptibly(long timeout, TimeUnit unit);//加了个单位
       V getNow();//没有完成就返回空，有结果就返回结果
    


ChannelFuture  继承 Future<Void>
    /*
    所有IO操作再netty里面都是异步的，这意味着任何IO的调用将会立即返回，但是不保证IO调用完成后 IO操作会执行完成
    将返回一个{@link ChannelFuture}实例，该实例提供有关I/O操作结果或状态的信息。
   一个 {@link ChannelFuture}要么是<em>未完成的</em>要么是<em>已完成的</em>。当I/O操作开始时，将创建一个新的未来对象。新的未来最初未完成-它既没有成功、失败，也没有取消，因为I/O操作尚未完成。如果I/O操作成功、失败或通过取消完成，则未来将标记为已完成，并包含更具体的信息，例如失败的原因。请注意，即使是失败和取消都属于完成状态。
    
 *                                      +---------------------------+
 *                                      | Completed successfully    |
 *                                      +---------------------------+
 *                                 +---->      isDone() = true      |
 * +--------------------------+    |    |   isSuccess() = true      |
 * |        Uncompleted       |    |    +===========================+
 * +--------------------------+    |    | Completed with failure    |
 * |      isDone() = false    |    |    +---------------------------+
 * |   isSuccess() = false    |----+---->      isDone() = true      |
 * | isCancelled() = false    |    |    |       cause() = non-null  |
 * |       cause() = null     |    |    +===========================+
 * +--------------------------+    |    | Completed by cancellation |
 *                                 |    +---------------------------+
 *                                 +---->      isDone() = true      |
 *                                      | isCancelled() = true      |
 *                                      +---------------------------+
 * +------------------------图1-------------------------------------+
提供了各种方法，让您检查I/O操作是否已完成，等待完成，并检索I/O操作的结果。它还允许您添加多个channelfuturelister，以便在I/O操作完成时收到通知。 
 
建议尽可能选择{@link#addListener（GenericFutureListener）}而不是{@link#await（）}，以便在I/O操作完成时得到通知并执行任何后续任务。 

{@link#addListener（GenericFutureListener）}不是阻塞方法。它只需将指定的{@link        channelfuturelister}添加到{@link ChannelFuture}，当与future关联的I/O操作完成时，I/O线程将通知这些listener。{@link channelfuturelister}产生最佳的性能和资源利用率，因为它根本不会阻塞

相比之下，{@link#await（）}是一个阻塞操作。调用后，调用方线程将阻塞，直到操作完成。用{@link#await（）}实现一个顺序逻辑比较容易，但是调用方的线程会造成不必要地阻塞，直到I/O操作完成，而且线程间通知的成本相对较高。此外，在特定的情况下也有可能发生死锁，如下所述。
  Do not call {@link #await()} inside {@link ChannelHandler}
  {@link ChannelHandler}中的事件处理程序方法通常由I/O线程调用。如果由IO线程调用事件处理方法中又调用{@link#await（）}，则它正在等待的I/O操作 可能 永远不会完成，因为{@link#await（）}可以阻止它正在等待的I/O操作，这是一个死锁。
  下面是一段可能造成死锁的代码
 * public void channelRead({@link ChannelHandlerContext} ctx, Object msg) {
 *     ChannelFuture future = ctx.channel().close();
 *     future.awaitUninterruptibly();
 *     // Perform post-closure operation
 *     // ...
 * }
 正确的做法
 * public void channelRead({@link ChannelHandlerContext} ctx, Object msg) {
 *     ChannelFuture future = ctx.channel().close();
 *     future.addListener(new {@link ChannelFutureListener}() {
 *         public void operationComplete({@link ChannelFuture} future) {
 *             // Perform post-closure operation
 *             // ...
 *         }
 *     });
 * }
   
 尽管{@link#await（）}存在上述缺点，但在某些情况下，调用{@link#await（）}更方便。在这种情况下，请确保不要在I/O线程中调用{@link#await（）}。否则，将引发{@link BlockingOperationException}异常来防止死锁。
    不要混淆I/O超时和等待超时
    使用{@link#await（long）}、{@link#await（long，TimeUnit）}、{@link#awaitinterruptible（long）}或{@link#awaitinterruptible（long，TimeUnit）}指定的超时值与I/O超时完全无关。如果I/O操作超时，则未来将被标记为“已完成但失败”，如上图1所示。例如，应通过传输特定选项配置IO连接超时：
    错误的方式
 * {@link Bootstrap} b = ...;
 * {@link ChannelFuture} f = b.connect(...);
 * 上面是一些列 启动配置操作代码
 * f.awaitUninterruptibly(10, TimeUnit.SECONDS);
 * if (f.isCancelled()) {
 *     // Connection attempt cancelled by user
 * } else if (!f.isSuccess()) {
 *     // You might get a NullPointerException here because the future
 *     // might not be completed yet.
 *     f.cause().printStackTrace();
 * } else {
 *     // Connection established successfully
 * }
   正确的方式
 * {@link Bootstrap} b = ...;
 * // Configure the connect timeout option.
 * <b>b.option({@link ChannelOption}.CONNECT_TIMEOUT_MILLIS, 10000);</b>
 * {@link ChannelFuture} f = b.connect(...);
 * f.awaitUninterruptibly();
 *
 * // Now we are sure the future is completed.
 * assert f.isDone();
 *
 * if (f.isCancelled()) {
 *     // Connection attempt cancelled by user
 * } else if (!f.isSuccess()) {
 *     f.cause().printStackTrace();
 * } else {
 *     // Connection established successfully
 * }
 
  Returns a channel where the I/O operation associated with this future takes place.
   */
    api：
     Channel channel();//返回与此future关联的I/O操作发生的channel。
为什么ChannelFuture可以Channel对象?因为所有IO操作异步执行，每一个IO操作就对应了一个Channel

netty的ChannelPromise

具有可写能力的特殊{@link ChannelFuture}。

Promise<V> 继承  Future<V>
  可写的特殊{@link Future}。
    api:
      Promise<V> setSuccess(V result);// 将此Future标记为成功并通知所有listeners。如果已经被标记成功或失败，它将抛出{@link IllegalStateException}。
      boolean trySuccess(V result);//将此Future标记为成功并通知所有listeners，返回true，就代表标记成功 ，如果为false，就代表以前已经被标记过了
      Promise<V> setFailure(Throwable cause);//自己猜吧
      boolean tryFailure(Throwable cause);//自己猜吧
      boolean setUncancellable();//使这个Future无法取消。{@code true}如果且仅当成功将此Future标记为不可取消，或者已完成但未被取消。{@code false}如果此Future已被取消。


ChannelPromise 继承 ChannelFuture 和 Promise<Void>

    作用

    举个例子
    /*
      ChannelFuture test(){
        
        ChannelPromise promise  =new ChannelPromiseImpl();
        executor.execute(()->{ task(promise) });
        return promise
        
     }
     void task(ChannelPromise  promise){
       if 成功  promise.trySuccess(V result);  
       if 失败  promise.tryFailure(Throwable cause);
     }
     
    
    */

netty的ChannelPipeline

A list of {@link ChannelHandler}s which handles or intercepts inbound events and outbound operations of a {@link Channel}.

是一个处理或拦截{@link Channel}的入站事件(inbound events)和出站操作(outbound operations)的{@link ChannellHandler}的列表。

（其实是一个 ChannelHandlerContext的链表，因为ChannelHandlerContext有一个handler()方法可以获取一个ChannellHandler，所以也就是 ChannellHandler的链表

当一个ChannellHandler对象再添加到pipeline中时，会产生一个带有ChannellHandler对象引用的ChannelHandlerContext对象，加到pipeline的链表中

pipeline中区分ChannellHandler是否已经添加通过指定的name来区分的，不指定的话会默认生成一个name

）

ChannelPipeline  继承 Iterable<Entry<String, ChannelHandler>>
    /*
    {@link ChannelPipeline}实现了 拦截过滤器模式的高级形式，使用户可以完全控制 如何处理事件 以及Pipeline中的{@link ChannelHandler}如何相互交互。
    
    创建pipeline：
         每个channel都有自己的pipeline，在创建channel实例时会自动创建pipeline实例。
         
    events如何在pipeline中流动：
         下图2描述了{@link ChannelPipeline}中的{@link ChannelHandler}s通常如何处理I/O事件。I/O事件由{@link ChannelInboundHandler}或{@link ChannelOutboundHandler}处理，并通过调用{@link ChannelHandlerContext}中定义的事件传播方法（例如ChannelHandlerContext#fireChannelRead（Object）和ChannelHandlerContext#write（Object）） 转发到其最近的处理程序（就是下一个handler）。 
 * <pre>
 *                                                 I/O Request
 *                                            via {@link Channel} or
 *                                        {@link ChannelHandlerContext}
 *                                                      |
 *  +---------------------------------------------------+---------------+
 *  |                           ChannelPipeline         |               |
 *  |                                                  \|/              |
 *  |    +---------------------+            +-----------+----------+    |
 *  |    | Inbound Handler  N  |            | Outbound Handler  1  |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  |               |
 *  |               |                                  \|/              |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |    | Inbound Handler N-1 |            | Outbound Handler  2  |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  .               |
 *  |               .                                   .               |
 *  | ChannelHandlerContext.fireIN_EVT() ChannelHandlerContext.OUT_EVT()|
 *  |        [ method call]                       [method call]         |
 *  |               .                                   .               |
 *  |               .                                  \|/              |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |    | Inbound Handler  2  |            | Outbound Handler M-1 |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  |               |
 *  |               |                                  \|/              |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |    | Inbound Handler  1  |            | Outbound Handler  M  |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  |               |
 *  +---------------+-----------------------------------+---------------+
 *                  |                                  \|/
 *  +---------------+-----------------------------------+---------------+
 *  |               |                                   |               |
 *  |       [ Socket.read() ]                    [ Socket.write() ]     |
 *  |                                                                   |
 *  |  Netty Internal I/O Threads (Transport Implementation)            |
 *  +-------------------------------------------------------------------+
 * </pre>    图2   
 
 一个入站事件（inbound event）由入站处理者（inbound handlers）按自下而上的方向处理，如图左侧所示。入站处理者（inbound handler）通常处理由 图2底部的I/O线程生成的入站数据。入站数据（inbound data）通常通过实际的输入操作（如{@link SocketChannel#read（ByteBuffer）}）从远程对等机读取。如果入站事件（inbound event）超出了顶级入站处理者（Inbound Handler  N ），则会自动丢弃该事件，或者如果需要关注这些事件，则会记录该事件日志。
 
一个出站事件（outbound event）由出站处理者（outbound handler）按自顶向下的方向处理，如图2右侧所示。出站处理者 通常生成或转换 出站流量，如写请求。如果出站事件超出底部出站处理者（Outbound Handler  M ），则由与{@link Channel}关联的I/O线程处理。I/O线程通常执行实际的输出操作，例如{@link SocketChannel#write（ByteBuffer）}。

例如，假设我们创建了以下Pipeline：
 * <pre>
 * {@link ChannelPipeline} p = ...;
 * p.addLast("1", new InboundHandlerA());
 * p.addLast("2", new InboundHandlerB());
 * p.addLast("3", new OutboundHandlerA());
 * p.addLast("4", new OutboundHandlerB());
 * p.addLast("5", new InboundOutboundHandlerX());
 * </pre>
  在上面的示例中，名称以{@code Inbound}开头的类意味着它是一个入站处理者。名称以{@code Outbound}开头的类表示它是出站处理者
  在给定的示例配置中，当事件进入入站时，处理程序求值顺序为1、2、3、4、5。当事件出站时，顺序是5、4、3、2、1。除此之外，{@link ChannelPipeline}跳过某些处理程序的求值以缩短堆栈深度：
        3和4不实现{@link ChannelInboundHandler}，因此入站事件的实际计算顺序为：1、2和5。
        1和2不实现{@link ChannelOutboundHandler}，因此出站事件的实际计算顺序为：5、4和3。
        如果5同时实现{@link ChannelInboundHandler}和{@link ChannelOutboundHandler}，则入站和出站事件的计算顺序分别为125和543。
        
将事件转发到下一个处理者（handler）
   如图2所示，处理者必须调用{@link ChannelHandlerContext}中的事件传播方法才能将事件转发给下一个处理者。这些方法包括：
        入站事件传播方法：
              ChannelHandlerContext#fireChannelRegistered() 
              ChannelHandlerContext#fireChannelActive()
              ChannelHandlerContext#fireChannelRead(Object)
              ChannelHandlerContext#fireChannelReadComplete()
              ChannelHandlerContext#fireExceptionCaught(Throwable)
              ChannelHandlerContext#fireUserEventTriggered(Object)
              ChannelHandlerContext#fireChannelWritabilityChanged()
              ChannelHandlerContext#fireChannelInactive()
              ChannelHandlerContext#fireChannelUnregistered()
         出站事件传播方法：    
              ChannelHandlerContext#bind(SocketAddress, ChannelPromise)
              ChannelHandlerContext#connect(SocketAddress, SocketAddress, ChannelPromise)
              ChannelHandlerContext#write(Object, ChannelPromise)
              ChannelHandlerContext#flush()
              ChannelHandlerContext#read()
              ChannelHandlerContext#disconnect(ChannelPromise)
              ChannelHandlerContext#close(ChannelPromise)
              ChannelHandlerContext#deregister(ChannelPromise)
   下面的示例显示了事件传播通常是如何完成的：
 * <pre>
 * public class MyInboundHandler extends  ChannelInboundHandlerAdapter {
 *    
 *     public void channelActive(ChannelHandlerContext ctx) {
 *         System.out.println("Connected!");
 *         ctx.fireChannelActive();
 *     }
 * }
 *
 * public clas MyOutboundHandler extends ChannelOutboundHandlerAdapter {
 *    
 *     public void close(ChannelHandlerContext ctx,ChannelPromise promise) {
 *         System.out.println("Closing ..");
 *         ctx.close(promise);
 *     }
 * }
 * </pre>
 
 
 构建Pipeline：
    使用者应该在Pipeline中有一个或多个{@link ChannelHandler}来接收I/O事件（如读取）和请求I/O操作（如写入和关闭）。例如，典型的服务器在每个channel的Pipeline中都有以下处理程序，但根据协议和业务逻辑的复杂性和特性，您的构建方式可能会有所不同：
* <li>Protocol Decoder - 将二进制数据（例如{@link ByteBuf}）转换为Java对象。</li>   
* <li>Protocol Encoder - 将Java对象转换为二进制数据。</li>                          
* <li>Business Logic Handler -执行实际的业务逻辑（例如数据库访问）。</li>      
   可以用下面的例子来表示：
* <pre>          
* static final EventExecutorGroup group = new DefaultEventExecutorGroup(16);      
* ...          
* ChannelPipeline pipeline = ch.pipeline();
* pipeline.addLast("decoder", new MyProtocolDecoder());  
* pipeline.addLast("encoder", new MyProtocolEncoder());  
*
* // 告诉pipeline运行MyBusinessLogicHandler的事件处理程序方法  
* // 这个处理程序方法不要运行再IO线程中，以便I/O线程不会被耗时的任务阻塞。                       
* // 如果您的业务逻辑完全异步或完成得非常快，则不需要指定 事件执行组(线程池)。                   
* pipeline.addLast(group, "handler", new MyBusinessLogicHandler());                       
* </pre>                                                                                 
  
  
线程安全：
   {@link ChannelHandler}可以随时添加或删除，因为{@link ChannelPipeline}是线程安全的。例如，可以在即将交换敏感信息 时 插入加密处理程序，并在交换后将其删除。（随时加随时删）                                                                                        
    */
   api：
     
   -------上面那一部分猜意思，或者自己看api文档------                                                                               
    ChannelPipeline fireChannelRegistered();这是一个入站事件传播的方法，那么看看逻辑具体怎么传播的
    
  ///--------------------------------------------------------////
    head就是 存储ChannelHandlerContext对象的链表的头
    ChannelHandlerContext对象有handler信息，也可以获取所属的pipeline，那么也可以获取 Channel信息
    
    第一步
   @Override
    public final ChannelPipeline fireChannelRegistered() {
        AbstractChannelHandlerContext.invokeChannelRegistered(head);
        return this;
    }  
  第二步
     static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {
        EventExecutor executor = next.executor(); //默认channel().eventLoop();
        if (executor.inEventLoop()) {
            next.invokeChannelRegistered();
        } else {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    next.invokeChannelRegistered();
                }
            });
        }
    }
 第三步
   private void invokeChannelRegistered() {
        if (invokeHandler()) {
            try {
                ((ChannelInboundHandler) handler()).channelRegistered(this);
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            fireChannelRegistered();
        }
    }
  第四步
      这是 pipeline里面链表的头节点实现
      public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
            invokeHandlerAddedIfNeeded();
            ctx.fireChannelRegistered();  
      
        }
   第五步
       @Override
    public ChannelHandlerContext fireChannelRegistered() {
        invokeChannelRegistered(findContextInbound());
        return this;
    }
   第六步
      private AbstractChannelHandlerContext findContextInbound() {
        AbstractChannelHandlerContext ctx = this;
        do {
            ctx = ctx.next;
        } while (!ctx.inbound);
        return ctx;
    }
第七步
    static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            next.invokeChannelRegistered();
        } else {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    next.invokeChannelRegistered();
                }
            });
        }
    }
第七步与第二步是一样的逻辑；只是 参数next被换掉了
    
    ChannelPipeline的传播方法 ，其实是调用的 ChannelHandlerContext的传播方法
    只不过ChannelPipeline的传播方法从head节点开始进行传播
    
     ChannelHandlerContext的传播方法 是当前节点找到下一个 节点进行传播

netty的ChannelHandlerContext

使{@link ChannelHandler}能够与其{@link ChannelPipeline}和其他 ChannelHandler交互。 ChannelHandler 可以通知{@link ChannelPipeline}中的下一个{@link ChannelHandler}，动态修改它所属的{@link channelpipeline}。

ChannelHandlerContext 继承 AttributeMap
    /*
通知：
   通过调用此处提供的各种方法，可以通知同一个{@link ChannelPipeline}中最近的处理者。请参阅{@link ChannelPipeline}以了解事件如何流动。
   
修改Pipeline：
   您可以通过调用{@link#pipeline（）}来获取处理程序所属的{@link ChannelPipeline}。特殊的应用程序可以在运行时动态地在pipeline中插入、移除或替换处理者。
   
检索以供以后使用：
   您可以保留{@link ChannelHandlerContext}以供以后使用，例如在 外部触发事件调用处理者方法 ，即使是从不同的线程。 例如：
 * <pre>
 * public class MyHandler extends ChannelDuplexHandler {
 *
 *     private  ChannelHandlerContext ctx;
 *
 *     public void beforeAdd(ChannelHandlerContext ctx) {
 *         <b>this.ctx = ctx;</b>
 *     }
 *
 *     public void login(String username, password) {
 *         ctx.write(new LoginMessage(username, password));
 *     }
 *     ...
 * }
 * </pre>
   
存储状态信息：
     {@link#attr（AttributeKey）}允许您存储和访问 与处理者 及其 上下文相关的状态信息。请参阅{@link ChannelHandler}了解管理状态信息的各种推荐方法。
    
处理者可以有多个上下文：   
     请注意，{@link ChannelHandler}实例可以添加到多个{@link ChannelPipeline}。这意味着单个{@link ChannelHandler}实例可以有多个{@link ChannelHandlerContext}，因此，如果多次将 一个处理者实例添加到一个或多个{@link ChannelPipeline}中，则可以使用不同的{@link ChannelHandlerContext}调用该处理者实例。
     例如，以下处理者的独立{@link AttributeKey}数量与添加到管道的次数相同，而不管它是多次添加到同一管道还是多次添加到不同管道：    
 * <pre>
 * public class FactorialHandler extends ChannelInboundHandlerAdapter<Integer> {
 *
 *  private final AttributeKey<Integer> counter=new AttributeKey<Integer>("counter");
 *
 *   //  此处理者将接收一个从1开始的递增整数序列
 *   @Override
 *   public void channelRead(ChannelHandlerContext ctx, Object msg) {
 *     Integer a = ctx.attr(counter).get();
 *
 *     if (a == null) {
 *       a = 1;
 *     }
 *
 *     attr.set(a * integer));
 *   }
 * }
 *
 * 
 *    不同的上下文对象被赋予“f1”、“f2”、“f3”和“f4”，即使它们引用同一个处理者。由于FactorialHandler将其
 *    状态存储在上下文对象中（作为（使用{@link AttributeKey}），因此一旦两个管道（p1和p2）处于活动状
 *    态（已连接状态），factorial将被计算4次。
 * FactorialHandler fh = new FactorialHandler();
 *
 * ChannelPipeline p1 = Channels.pipeline();
 * p1.addLast("f1", fh);
 * p1.addLast("f2", fh);
 *
 * ChannelPipeline p2 = Channels.pipeline();
 * p2.addLast("f3", fh);
 * p2.addLast("f4", fh);
 * </pre>    
 
 其他值得阅读的资源
     请参阅{@link ChannelHandler}和{@link ChannelPipeline}以了解有关入站和出站操作的更多信息，它们有哪些基本区别，它们如何在管道中流动，以及如何在应用程序中处理操作。
    */
    api:
       Channel channel();//返回绑定到{@link ChannelHandlerContext}的{@link Channel}。
       EventExecutor executor();//用于分派事件的{@link EventExecutor}。这也可以用于直接提交在事件循环中执行的任务。有关更多信息，请参阅{@link EventExecutor}javadoc。
      String name();//{@link ChannelHandlerContext}的唯一名称。将{@link ChannelHandler}添加到{@link ChannelPipeline}时使用该名称。此名称还可用于从{@link ChannelPipeline}访问注册的{@link ChannelHandler}。
      ChannelHandler handler();   
      ChannelPipeline pipeline();

      -----其他api不写了-- 因为有了这几个方法 其实ChannelHandlerContext基本上可以 为所欲为

    /**
     * 返回一个特殊的ChannelPromise，它可以为不同的操作重用。
     * 它只支持用于{@link ChannelHandlerContext#write（Object，ChannelPromise）}。
     * 请注意，返回的{@link ChannelPromise}将不支持大多数操作，仅当要为每个写操作保存对象分配时
     * 才应使用。这样使用也无法检测操作是否已完成，除非操作失败，因为在这种情况下，
     * 将调用{@link ChannelPipeline#firexceptioncaught（Throwable）}。
     * <strong>请注意这是一个专家功能，应该小心使用！(意思就是要很清楚原理，才能合理的使用)</strong>
     */
    //这个返回的对象 是无法对未来完成的操作进行检测的
   //其实看它实现，就是用来传播异常用的，所以只有写事件 可以使用，因为有时候不需要获取是否写完的信息
    ChannelPromise voidPromise();

netty的ChannelHandler

Handles or intercepts a {@link ChannelInboundInvoker} or {@link ChannelOutboundInvoker} operation, and forwards it to the next handler in a {@link ChannelPipeline}.

处理或拦截 {@link ChannelInboundInvoker}或{@link ChannelOutboundInvoker}操作，并将其转发到{@link ChannelPipeline}中的下一个处理者（handler）。

ChannelHandler
/*
子类：
   {@link ChannelHandler}本身不提供许多方法。要处理{@link ChannelInboundInvoker}或{@link ChannelOutboundInvoker}操作，需要实现其子接口。有许多不同的子接口来处理入站和出站操作。
   但对于开发人员来说，最有用的可能是：
            ChannelInboundHandlerAdapter   处理和拦截入站操作(例如IO读取) 
            ChannelOutboundHandlerAdapter  处理和拦截出站操作(例如IO写出)
   您还可以从每个子接口的文档中找到更详细的解释去说明一个事件被拦截 当它分别进入上游（读IO）和下游（写IO）时

上下文对象：
   一个{@link ChannelHandler}提供了一个{@link ChannelHandlerContext}对象。{@link ChannelHandler}应该通过上下文对象与它所属的{@link ChannelPipeline}交互。使用context对象，{@link ChannelHandler}可以向上下游传递事件、动态修改管道或存储特定于处理者的信息（使用{@link AttributeKey}）。
   
状态管理：
   {@link ChannelHandler}通常需要存储一些状态信息。最简单和推荐的方法是使用成员变量,例如：
 * <pre>
 * public interface Message {
 *     // your methods here
 * }
 *
 * public class DataServerHandler extends SimpleChannelInboundHandler<Message> {
 *
 *     private boolean loggedIn;
 *
 *     @Override
 *     public void channelRead0(ChannelHandlerContext ctx, Message message) {
 *         Channel ch = e.getChannel();
 *         if (message instanceof LoginMessage) {
 *             authenticate((LoginMessage) message);
 *             loggedIn = true;
 *         } else (message instanceof GetDataMessage) {
 *             if (loggedIn) {
 *                 ch.write(fetchSecret((GetDataMessage) message));
 *             } else {
 *                 fail();
 *             }
 *         }
 *     }
 *     ...
 * }
 * </pre>
 
由于处理者实例有一个专用于一个连接的状态变量，因此必须为每个新channel创建一个新的处理者实例，以避免出现未经身份验证的客户端可以获取机密信息跳过验证条件：   
 * <pre>
 * // 为每个通道创建一个新的处理程序实例。
 * // 详情请看ChannelInitializer#initChannel(Channel).
 * public class DataServerInitializer extends ChannelInitializer<Channel> {
 *     @Override
 *     public void initChannel(Channel channel) {
 *         channel.pipeline().addLast("handler", new DataServerHandler());
 *     }
 * }
 *
 * </pre>
  
 使用 {@link AttributeKey} ：
     尽管建议使用成员变量来存储处理程序的状态，但出于某些原因，您可能不希望创建许多处理者实例。在这种情况下，可以使用{@link ChannelHandlerContext}提供的{@link AttributeKey}：
 * <pre>
 * public interface Message {
 *     // your methods here
 * }
 *
 * @Sharable
 * public class DataServerHandler extends SimpleChannelInboundHandler<Message>{
 *     private final AttributeKey<Boolean> auth = AttributeKey.valueOf("auth")
 *           
 *
 *     @Override
 *     public void channelRead(ChannelHandlerContext ctx, Message message) {
 *         Attribute<Boolean> attr = ctx.attr(auth);
 *         Channel ch = ctx.channel();
 *         if (message instanceof LoginMessage) {
 *             authenticate((LoginMessage) o);
 *             attr.set(true);
 *         } else (message instanceof GetDataMessage) {
 *             if (Boolean.TRUE.equals(attr.get())) {
 *                 ch.write(fetchSecret((GetDataMessage) o));
 *             } else {
 *                 fail();
 *             }
 *         }
 *     }
 *     ...
 * }
 * </pre>  
 
 现在处理者的状态已附加到{@link ChannelHandlerContext}，您可以将相同的处理程序实例添加到不同的管道：
 * <pre>
 * public class DataServerInitializer extends ChannelInitializer<Channel> {
 *
 *     private static final DataServerHandler SHARED = new DataServerHandler();
 *
 *     @Override
 *     public void initChannel({@link Channel} channel) {
 *         channel.pipeline().addLast("handler", SHARED);
 *     }
 * }
 * </pre> 
 
 @Sharable注释:
    在上面使用{@link AttributeKey}的示例中，您可能注意到了@Sharable注释。
    如果{@link ChannelHandler}使用@Sharable注释进行注释，则意味着您可以只创建一次处理者的实例，并将其多次添加到一个或多个{@link ChannelPipeline}中，而无需争用条件。
  如果未指定此 注解，则每次将其添加到管道时都必须创建新的处理程序实例，因为它具有非共享状态（如成员变量）。
  这个注释是为文档目的而提供的，就像JCIP注释一样
  
  意思就是一个handler多次被添加 如果没有这么注解就会报错
  *  private static void checkMultiplicity(ChannelHandler handler) {
  *      if (handler instanceof ChannelHandlerAdapter) {
  *          ChannelHandlerAdapter h = (ChannelHandlerAdapter) handler;
  *          if (!h.isSharable() && h.added) {
  *              throw new ChannelPipelineException(
  *                      h.getClass().getName() +
  *                      " is not a @Sharable handler, so can't be added or removed multiple times.");
  *         }
  *          h.added = true;
  *      }
  *  }

  
其他值得阅读的资源:  
    请参阅{@link ChannelHandler}和{@link ChannelPipeline}以了解有关入站和出站操作的更多信息，它们有哪些基本区别，它们如何在管道中流动，以及如何在应用程序中处理操作。
    
   @SuppressWarnings({ "UnusedDeclaration", "deprecation" }) // 'T' is used only at compile time 
    
    
  读完之后：Channel， ChannelHandler， ChannelPipeline ，ChannelHandlerContext 这四者的联系
  
  一个channel的inbound and outbound 操作  会经过ChannelPipeline进行处理，而该ChannelPipeline里面有一串ChannelHandlerContext，每一个ChannelHandlerContext都持有ChannelHandler的应用
  
 
  那么一个Channel   对应一个 ChannelPipeline
  那么一个ChannelPipeline对应多个ChannelHandlerContext
  那么一个ChannelHandlerContext对应一个ChannelHandler
  
*/
    api:
       void handlerAdded(ChannelHandlerContext ctx) throws Exception;//在{@link ChannelHandler}添加到pipeline，pipeline的channel注册到EventLoop后启动线程，然后回调此方法
       void handlerRemoved(ChannelHandlerContext ctx) throws Exception;//在{@link ChannelHandler}从pipeline删除，然后回调此方法
       void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;//如果在处理此 hanlder时抛出{@link Throwable}，则调用。

netty的EventExecutorGroup

{@link EventExecutorGroup}负责提供多个{@link EventExecutor}以通过其{@link #next（）}方法使用。除此之外，它还负责处理它们的生命周期，并允许以全局方式关闭它们。

EventExecutorGroup 继承 ScheduledExecutorService, Iterable<EventExecutor>
     /*
     具备可延时调度线程池的特点，具备迭代EventExecutor的特点
     */
    api：
      boolean isShuttingDown();//返回{@code true}如果且仅当此执行器执行完{@linkplain#shutdownlessfully（）shutdownlessfully}或{@linkplain#isShutdown（）shut down}。

       Future<?> shutdownGracefully();//{@link #shutdownGracefully（long，long，TimeUnit）}的快捷方式方法。具有合理的默认值

      Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit);//向想要关闭的executor发送信号，这个方法一旦被调用，{@link #isShuttingDown()} 就会返回true，并且收到信号的executor准备开始关闭自己，他不像 {@link #shutdown()}，该方法优雅的关闭方式 确保了静默期(the quiet period) 将不会再有任务被提交上来再executor关闭自己之前，如果有任务是在静默期提交的，则保证它被接受，the quiet period 将重新开始一个新的 静默期，就是重新准备关闭。timeout：executor等待的最长时间 {@linkplain#shutdown（）}无论任务是否在安静期间提交；quietPeriod:静默期时

   Future<?> terminationFuture();// 返回{@link Future}，当这个执行器被终止时，它会得到通知。

   EventExecutor next();//返回属于此组的{@link EventExecutor}之一。

EventLoopGroup：
    特殊的{@link EventExecutorGroup}，它允许注册{@link Channel}，以便在事件循环期间进行后续选择。
    api:
        EventLoop next();//返回要使用的下一个{@link EventLoop}
        ChannelFuture register(Channel channel);//用这个{@link EventLoop}注册{@link Channel}。注册完成后，将通知返回的{@link ChannelFuture}。
        ChannelFuture register(Channel channel, ChannelPromise promise);//用这个{@link EventLoop}注册{@link Channel}。一旦注册完成，指定的{@link ChannelFuture}将得到通知，并且也将被返回。
       
EventLoop： 继承 EventLoopGroup，OrderedEventExecutor
    channel注册后将处理{@link Channel}的所有I/O操作。
    一个{@link EventLoop}实例通常处理多个{@link Channel}，但这可能取决于实现细节和内部。
      
    
    
EventExecutor  继承 EventExecutorGroup
    {@link EventExecutor}是一个特殊的{@link EventExecutorGroup}，它附带了一些方便的方法来查看{@link Thread}是否在事件循环中执行。除此之外，它还扩展了{@link EventExecutorGroup}，以允许使用通用方法访问方法。
     api：
       EventExecutor next();//返回一个引用给自己
       EventExecutorGroup parent();//返回{@link EventExecutorGroup}，它是{@link EventExecutor}的父级，
       boolean inEventLoop();//使用当前线程Thread#currentThread()作为参数调用{@link inEventLoop（Thread）}

       boolean inEventLoop(Thread thread);//如果给定的{@link Thread}在事件循环中执行，则返回{@code true}，否则返回{@code false}。

       <V> Promise<V> newPromise();//Return a new {@link Promise}.
        <V> ProgressivePromise<V> newProgressivePromise();

       <V> Future<V> newSucceededFuture(V result);
       <V> Future<V> newFailedFuture(Throwable cause);


AbstractEventExecutorGroup  实现 EventExecutorGroup
    /*
     做了一些基本实现，所有的任务执行 ，都通过 next()调用对应的方法，
      public void execute(Runnable command) {
        next().execute(command);
    }
    */
    
MultithreadEventExecutorGroup 继承 AbstractEventExecutorGroup
    /*
    {@link EventExecutorGroup}实现的抽象基类，这些实现同时使用多个线程处理其任务。
    
    private final EventExecutor[] children;
    private final AtomicInteger childIndex = new AtomicInteger();
    private final AtomicInteger terminatedChildren = new AtomicInteger();
    private final Promise<?> terminationFuture = new DefaultPromise(GlobalEventExecutor.INSTANCE);
    //EventExecutorChooser目前有两种，一个是二次幂的实现，一个是是通用的实现，其实就是取模的方式不同
    // 按位与的取模 会比较块，所以 children个数尽量设成2的次幂
    private final EventExecutorChooser chooser;
    private interface EventExecutorChooser {
        EventExecutor next();
    }  
   
    */
    EventExecutor[] children;
    children = new SingleThreadEventExecutor[nThreads];
    children[i] = newChild(threadFactory, args);

    public Future<?> terminationFuture() {
        return terminationFuture;//当所有的EventExecutor[]关闭之后，这个futrue才 Done
    }
    
     public EventExecutor next() {
        return chooser.next();//childIndex.getAndIncrement()每一次都++的方式，然后对数组长度取模，得到EventExecutor，简单来说就是 一组EventExecutor，每一次任务的提交都是轮着来
    }



MultithreadEventLoopGroup 继承MultithreadEventExecutorGroup 实现EventLoopGroup
    /*
    {@link EventLoopGroup}实现的抽象基类，这些实现同时使用多个线程处理其任务（这里的多个线程就是通过next()方法去提交任务）。
    private static final int DEFAULT_EVENT_LOOP_THREADS;//默认会获取本机cpu核数然后设置最佳个数的执行线程
    static {
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                "io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2));

        if (logger.isDebugEnabled()) {
            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
        }
    }
    
    */
    protected ThreadFactory newDefaultThreadFactory() {
        return new DefaultThreadFactory(getClass(), Thread.MAX_PRIORITY);
    }
    public ChannelFuture register(Channel channel) {
        return next().register(channel);
    }
    public ChannelFuture register(Channel channel, ChannelPromise promise) {
        return next().register(channel, promise);
    }
    
    

NioEventLoopGroup  继承 MultithreadEventLoopGroup
    /*
    {@link MultithreadEventLoopGroup}的实现，用于基于NIO{@link Selector}的{@link Channel}s。
     public NioEventLoopGroup() {  将会创建一个最佳线程数
        this(0);  
    }
    
    */
    
    public void setIoRatio(int ioRatio) {
    //设置子事件循环中I/O所需时间的百分比。默认值是{@code 50}，这意味着事件循环将尝试在I/O上花费与非I/O任务相同的时间。
        for (EventExecutor e: children()) {
            ((NioEventLoop) e).setIoRatio(ioRatio);
        }
    }

    public void rebuildSelectors() {
    //用新创建的{@link Selector}替换 子事件循环 的当前{@link Selector}，以解决臭名昭著的epoll 100%CPU bug。
        for (EventExecutor e: children()) {
            ((NioEventLoop) e).rebuildSelector();
        }
    }
    
   
    protected EventExecutor newChild(ThreadFactory threadFactory, Object... args) throws Exception {
        // 这就是NioEventLoopGroup的next()的实例
        return new NioEventLoop(this, threadFactory, (SelectorProvider) args[0],
            ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
    }
    


总结：
             EventExecutorGroup 1
   EventExecutor 2继承 1          EventLoopGroup 3 继承 1
 OrderedEventExecutor 4继承 2
                       EventLoop 5继承 4，3
                 
 再netty中，IO读写操作，都叫做事件，
 那么EventLoop，简单来说就是一个线程池， 有队列，拒绝策略，线程，下一个EventLoop的指针
 EventLoopGroup，简单来说就是一个线程池的组，可以把一个任务 选择性的丢进哪一个线程池。丢进去的规则也很简单，就是每个线程池轮着来， 把里面每一个EventLoop小线程池看成一个线程，那么其实EventLoopGroup是一个大的线程池了
 EventExecutor，事件执行器，简单来说就是一个线程
EventExecutorGroup，那就是所有线程的集合

内存管理模块名词

netty的ReferenceCounted

netty有自己的一套直接内存管理技术

需要显式释放的引用计数对象。


ReferenceCounted
    /*
    当一个新的{@link ReferenceCounted}被实例化时，它以{@code 1}的引用计数开始。{@link#retain（）}增加引用计数，{@link#release（）}减少引用计数。如果引用计数减少到{@code 0}，对象将被显式释放，访问被释放的对象通常会导致访问冲突。
    
    如果{@link ReferenceCounted}的对象 是 {@link ReferenceCounted}的其他对象的容器，则当容器的引用计数变为0时，所包含的对象也将通过{@link #release（）释放。


    */
  api：
    int refCnt();//返回此对象的引用计数。如果{@code 0}，则表示此对象已被释放。
     ReferenceCounted retain();//将引用计数增加{@code 1}。
    ReferenceCounted retain(int increment);//将引用计数增加指定的{@code increment}。
     boolean release();//将引用计数减少{@code 1}，如果引用计数达到{@code 0}，则释放此对象。如果返回{@code true}仅当引用计数变为{@code 0}并且此对象已被释放
       boolean release(int decrement);//将引用计数减少指定的{@code decrement}，如果引用计数达到{@code 0}，则释放此对象。如果返回{@code true}当且仅当引用计数变为{@code 0}并且此对象已被释放时

netty的ByteBuf

//无论是堆内存的还是直接内存的缓存区，无非两种形式，堆内用数组，直接内存就在对堆内存中申请一个连续的内存地址空间，说白了还是数组（数组就是连续的内存空间）

此时的读和写，都是使用内存地址指针进行操作，

1 获取申请的连续地址空间的首地址

2 获取偏移量

3 相加就是对应要修改或者读取的内存地址( 指针)

4 修改或者读取内存地址所对应这一段空间（指针所指的内容）

public native byte getByte(Object o, long offset);

public native void putByte(Object o, long offset, byte x);

ByteBuf 实现 ReferenceCounted 和 Comparable<ByteBuf> 
 /*
 一个0字节或者多字节 的随机且可访问的有序序列 
 这么 类 为 一个或者多个 原始字节数组（byte[]）和NIO的ByteBuffer提供一些抽象方法
 
 Creation of a buffer：
     建议使用{@link unpoled}中的helper方法创建新buffer，而不要调用单个实现的构造函数。
 
  随机访问索引：
     就像普通的基元字节数组一样，{@link ByteBuf}使用基于零的索引。这意味着第一个字节的索引总是{@code 0}，最后一个字节的索引总是{@link#capacity（）capacity-1}。例如，要迭代缓冲区的所有字节，无论其内部实现如何，都可以执行以下操作：
 * <pre>
 * ByteBuf buffer = ...;
 * for (int i = 0; i < buffer.capacity(); i ++) {
 *     byte b = buffer.getByte(i);
 *     System.out.println((char) b);
 * }
 * </pre>
  
  
 顺序访问索引：
    {@link ByteBuf}提供了两个指针变量来支持顺序读写操作-{@link#readerIndex（）readerIndex}用于读操作，而{@link#writerIndex（）writerIndex}用于写操作。下图显示了如何通过两个指针将缓冲区分割为三个区域：
         
 * <pre>
 *      +-------------------+------------------+------------------+
 *      | discardable bytes |  readable bytes  |  writable bytes  |
 *      |     可丢弃         |   未读  (CONTENT) |   可写           |
 *      +-------------------+------------------+------------------+
 *      |                   |                  |                  |
 *      0      <=      readerIndex   <=   writerIndex    <=    capacity
 * </pre> 
 
 可读区域（实际内容） (the actual content):
     这个段是存储实际数据的地方。任何名称以{@code read}或{@code skip}开头的操作都将 获取或跳过当前{@link#readerIndex（）readerIndex}处的数据，并将readerIndex增加读取字节数。如果读取操作的参数也是{@link ByteBuf}，并且未指定目标索引，则指定buffer的{@link#writerIndex（）writerIndex}将一起增加。
    如果没有足够的容量，将引发{@link IndexOutOfBoundsException}。新分配、包装或复制buffer的{@link#readerIndex（）readerIndex}的默认值是{@code 0}。
    
 * <pre>
 * // Iterates the readable bytes of a buffer.
 * ByteBuf buffer = ...;
 * while (buffer.isReadable()) {
 *     System.out.println(buffer.readByte());
 * }
 * </pre>   
   
 可写区域:
     此段是一个未定义的空间，需要被填充。任何名称以{@code write}开头的操作都将在当前的{@link#writerIndex（）writerIndex}处写入数据，并将writerIndex增加写入的字节数。如果写操作的参数也是{@link ByteBuf}，并且未指定源索引，则指定buffer的{@link#readerIndex（）readerIndex}将一起增加。
      如果没有足够的可写字节数，将引发{@link IndexOutOfBoundsException}。新分配buffer的{@link#writerIndex（）writerIndex}的默认值是{@code 0}。包装或复制buffer的{@link#writerIndex（）writerIndex}的默认值是缓冲区的{@link#capacity（）capacity}。
      
 * <pre>
 * // Fills the writable bytes of a buffer with random integers.
 * ByteBuf buffer = ...;
 * while (buffer.maxWritableBytes() >= 4) {
 *     buffer.writeInt(random.nextInt());
 * }     
   
  可丢弃字节区域：
  此段包含已被读取操作 读取的字节。最初，这个段的大小是{@code 0}，但是随着读取操作的执行，它的大小一直增加到{@link#readerIndex（）readerIndex}。可以通过调用{@link#discardeReadBytes（）}回收未使用的区域来丢弃读取的字节，如下图所示：
 * <pre>
 *  BEFORE discardReadBytes()
 *
 *      +-------------------+------------------+------------------+
 *      | discardable bytes |  readable bytes  |  writable bytes  |
 *      +-------------------+------------------+------------------+
 *      |                   |                  |                  |
 *      0      <=      readerIndex   <=   writerIndex    <=    capacity
 *
 *
 *  AFTER discardReadBytes()
 *
 *      +------------------+--------------------------------------+
 *      |  readable bytes  |    writable bytes (got more space)   |
 *      +------------------+--------------------------------------+
 *      |                  |                                      |
 * readerIndex (0) <= writerIndex (decreased)        <=        capacity
 * </pre> 
  请注意，在调用{@link\discardReadBytes（）}之后，无法保证可写字节区域的内容。在大多数情况下，可写字节不会被移动，甚至可以进行不同的数据填充 取决于 根据底层buffer实现
  
  
清除缓冲区索引:
    通过调用{@link#clear（），可以将{@link#readerIndex（）readerIndex}和{@link#writerIndex（）writerIndex}设置为{@code 0}。它不清除缓冲区内容（例如用{@code 0}填充），而只清除两个指针。请注意，此操作的语义不同于{@link ByteBuffer#clear（）}。
    操作差不多，含义不一样而已
 * <pre>
 *  BEFORE clear()
 *
 *      +-------------------+------------------+------------------+
 *      | discardable bytes |  readable bytes  |  writable bytes  |
 *      +-------------------+------------------+------------------+
 *      |                   |                  |                  |
 *      0      <=      readerIndex   <=   writerIndex    <=    capacity
 *
 *
 *  AFTER clear()
 *
 *      +---------------------------------------------------------+
 *      |             writable bytes (got more space)             |
 *      +---------------------------------------------------------+
 *      |                                                         |
 *      0 = readerIndex = writerIndex            <=            capacity
 * </pre>   
 
 搜索操作
     对于简单的单字节搜索，请使用{@link  #indexOf（int，int，byte）}和{@link#bytesfore（int，int，byte）}。在处理以{@code NUL}结尾的字符串时，{@link}bytesbevere（byte）}特别有用。对于复杂的搜索，使用{@link# forEachByte（int，int，ByteBufProcessor）}和{@link ByteBufProcessor}实现。


标记并重置：
    每个buffer中有两个标记索引。一个用于存储{@link#readerIndex（）readerIndex}，另一个用于存储{@link#writerIndex（）writerIndex}。始终可以通过调用reset方法重新定位两个索引之一。它的工作方式与{@link InputStream}中的mark和reset方法类似，只是没有{@code readlimit}。
    
派生buffer：
    可以通过调用{@link#duplicate（）}、{@link#slice（）}或{@link#slice（int，int）}来创建现有缓冲区的视图。派生缓冲区将具有独立的{@link#readerIndex（）readerIndex}、{@link#writerIndex（）writerIndex}和标记索引，同时它共享其他内部数据表示形式，就像NIO缓冲区一样。
    如果需要现有缓冲区的全新副本，请改为调用{@link\copy（）}方法。
    ****还要注意，获取派生缓冲区不会调用{@link\retain（）}，因此引用计数不会增加。
    
转换为现有JDK类型：
    Byte array：
       如果{@link ByteBuf}由字节数组（即{@code byte[]}）支持，则可以通过{@link#array（）方法直接访问它。要确定缓冲区是否由字节数组支持，应使用{@link\hasrarray（）}。
       
    NIO Buffers:
       如果{@link ByteBuf}可以转换为NIO{@link ByteBuffer}，它共享ByteBuf的内容（即视图buffer），可以通过{niobuffer()方法获取ByteBuffer。要确定缓冲区是否可以转换为NIO缓冲区，请使用{@link# nioBufferCount()}。
    Strings：
        各种{@link #toString（Charset）}方法将{@link ByteBuf}转换为{@link String}。请注意{@link#toString（）}不是转换方法。
     I/O Streams：
        请参考{@link bytebuffinputstream}和{@link bytebuffoutputstream}。
  */
    api:
       public abstract int capacity();//容量
       public abstract ByteBuf capacity(int newCapacity);//调整此缓冲区的容量。如果{@code newCapacity}小于当前容量，则此缓冲区的内容将被截断。如果{@code newCapacity}大于当前容量，缓冲区将附加长度为{@code（newCapacity-currentpacity）}的未指定数据。

      public abstract int maxCapacity();//返回此缓冲区允许的最大容量。如果用户试图使用{@link#capacity（int）}或{@link#ensureWritable（int）}将缓冲区的容量增加到最大容量之外，则这些方法将引发{@link IllegalArgumentException}。

       public abstract ByteBufAllocator alloc();//返回创建此缓冲区的{@link ByteBufAllocator}。

      public abstract ByteOrder order();//返回此缓冲区的endianness，（计算机网络传输的字节序，大端序和小端序两种）。

       public abstract ByteBuf order(ByteOrder endianness);//返回具有指定{@code endianness}的缓冲区，返回的缓冲区共享此缓冲区的整个区域、索引和标记。修改返回缓冲区或此缓冲区的内容、索引或标记会影响调用此方法的buffer的内容、索引和标记。如果指定的{@code endianness}与此缓冲区的字节顺序相同，则此方法可以返回{@code this}。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。


       public abstract ByteBuf unwrap();//如果此ByteBuf是另一个ByteBuf的包装器，则返回基础ByteBuf实例。如果返回null则此buffer不是包装器
     
        public abstract boolean isDirect();//如果返回true仅当此缓冲区由NIO直接缓冲区支持时，

       public abstract int readerIndex();
       public abstract ByteBuf readerIndex(int readerIndex);
        public abstract int writerIndex();
       public abstract ByteBuf writerIndex(int writerIndex);
     /*
     一次性设置此缓冲区的{@code readerIndex}和{@code writerIndex}。当需要担心{@link#readerIndex（int）}和{@link#writerIndex（int）}方法的调用顺序时，此方法非常有用。例如，以下代码将失败：
     * <pre>
     * //创建一个readerIndex、writerIndex和capacity分别为0、0和8的缓冲区。
     *  ByteBuf buf = Unpooled.buffer(8);
     *
     * // 引发IndexOutboundsException，因为指定的readerIndex（2）不能大于当前的writerIndex（0）。
     * buf.readerIndex(2);
     * buf.writerIndex(4);
     * </pre>
 以下代码也将失败：
     * <pre>
     * // 创建一个readerIndex、writerIndex和capacity分别为0、8和8的缓冲区。
     * ByteBuf buf = Unpooled.wrappedBuffer(new byte[8]);
     *
     * // readerIndex变为8。
     * buf.readLong();
     *
     * // 引发IndexAutofBoundsException，因为指定的writerIndex（4）不能小于当前的readerIndex（8）。
     * buf.writerIndex(4);
     * buf.readerIndex(2);
     * </pre>
     
     相反，该方法保证只要指定的索引满足基本约束，它就不会抛出{@link IndexOutOfBoundsException}，而不管缓冲区的当前索引值是什么
     * <pre>
     * // 不管缓冲区的当前状态是什么，只要缓冲区的容量不小于4，以下调用总是成功的。
     * buf.setIndex(2, 4);
     * </pre>
     
     */
      public abstract ByteBuf setIndex(int readerIndex, int writerIndex);//一句话，如果想要先后指定两个指针位置，就使用这个方法

      public abstract int readableBytes();//this.writerIndex - this.readerIndex
  
      public abstract int writableBytes();//this.capacity - this.writerIndex

     public abstract int maxWritableBytes();//this.maxCapacity - this.writerIndex
    public abstract boolean isReadable();//this.writerIndex - this.readerIndex>0
 public abstract boolean isReadable(int size);//this.writerIndex - this.readerIndex>size
   public abstract boolean isWritable();//this.capacity - this.writerIndex>0
  public abstract boolean isWritable(int size);

     public abstract ByteBuf clear();//setIndex(0, 0),请注意，此方法的行为与NIO buffer不同，NIO buffer将{@code limit}设置为缓冲区的{@code capacity}。
    
    public abstract ByteBuf markReaderIndex();//标记此缓冲区中的当前{@code readerIndex}。您可以通过调用{@link}resetReaderIndex（）将当前{@code readerIndex}重新定位到标记的{@code readerIndex}。标记的{@code readerIndex}的初始值是{@code 0}。
    public abstract ByteBuf resetReaderIndex();//将当前{@code readerIndex}重新定位到此缓冲区中标记的{@code readerIndex}。

    public abstract ByteBuf markWriterIndex();
    public abstract ByteBuf resetWriterIndex();


    //丢弃第0个索引和{@code readerIndex}之间的字节。它将{@code readerIndex}和{@code writerIndex}之间的字节移动到第0个索引，并将{@code readerIndex}和{@code writerIndex}分别设置为{@code 0}和{@code oldriterindex-oldReaderIndex}。
     public abstract ByteBuf discardReadBytes();

    
    // 类似于{@link ByteBuf#discardReadBytes()}，只是此方法可能会丢弃 一些、丢弃全部或不丢弃 读取字节，具体取决于其内部实现，以降低总体内存带宽消耗，同时可能会导致额外的内存消耗
    public abstract ByteBuf discardSomeReadBytes();

  
    //确保可写字节的{@linkplain#writeablebytes（）}数等于或大于指定值。如果缓冲区中有足够的可写字节，则此方法返回时不会产生任何副作用。否则，它会引发{@link IllegalArgumentException}。
    public abstract ByteBuf ensureWritable(int minWritableBytes);

  
   //尝试确保可写字节的{@linkplain#writeablebytes（）}数等于或大于指定值。与{@link#ensureWritable（int）}不同，此方法不会引发异常，而是返回code。
   //force=true则缓冲区的容量扩展到{@link#maxCapacity（）}
    public abstract int ensureWritable(int minWritableBytes, boolean force);

     //获取此缓冲区中指定index处的布尔值。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract boolean getBoolean(int index);

    public abstract byte  getByte(int index);

   //获取此缓冲区中指定index处的无符号字节。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract short getUnsignedByte(int index);

    //获取此缓冲区中指定index处的16位短整数。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract short getShort(int index);

    public abstract int getUnsignedShort(int index);

    public abstract int   getMedium(int index);//24位
    public abstract int   getUnsignedMedium(int index);

    public abstract int   getInt(int index);

    public abstract long  getUnsignedInt(int index);

    public abstract long  getLong(int index);

    //获取此缓冲区中指定index处的2字节UTF-16字符。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract char  getChar(int index);

    public abstract float getFloat(int index);

    public abstract double getDouble(int index);

    //从指定index开始将此缓冲区的数据传输到指定的目标，直到目标变为不能写。此方法与{@link#getBytes（int，ByteBuf，int，int）}基本相同，只是此方法按传输的字节数增加dst的{@code writerIndex}，而{@link#getBytes（int，ByteBuf，int，int）}不增加。此方法不修改源缓冲区的{@code readerIndex}或{@code writerIndex}（即{@code This}）。
    public abstract ByteBuf getBytes(int index, ByteBuf dst);

     //从指定index开始将此缓冲区的数据传输到指定的目标。此方法与{@link#getBytes（int，ByteBuf，int，int）}基本相同，只是此方法将dst的{@code writerIndex}增加传输的字节数，而{@link#getBytes（int，ByteBuf，int，int）}不增加。此方法不修改源缓冲区的{@code readerIndex}或{@code writerIndex}（即{@code This}）。
    public abstract ByteBuf getBytes(int index, ByteBuf dst, int length);

   //从指定的index开始将此缓冲区的数据传输到指定的目标。此方法不修改源（即{@code This}）和dst的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length);

    //从指定的index开始将此缓冲区的数据传输到指定的目标。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}
    public abstract ByteBuf getBytes(int index, byte[] dst);

    public abstract ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length);

   //从指定的index开始将此缓冲区的数据传输到指定的目标，直到目标位置达到其limit。dst的{@code position}将增加，此方法不会修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf getBytes(int index, ByteBuffer dst);

     //从指定的index开始将此缓冲区的数据传输到指定的流。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf getBytes(int index, OutputStream out, int length) throws IOException;

    public abstract int getBytes(int index, GatheringByteChannel out, int length) throws IOException;

    //在此缓冲区中的指定index处设置指定的布尔值。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf setBoolean(int index, boolean value);

    //在此缓冲区中的指定index处设置指定字节。指定值的24个高阶位是忽略。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf setByte(int index, int value);

    public abstract ByteBuf setShort(int index, int value);

    public abstract ByteBuf setMedium(int index, int value);

    public abstract ByteBuf setInt(int index, int value);

    public abstract ByteBuf setLong(int index, long value);

    public abstract ByteBuf setChar(int index, int value);

    public abstract ByteBuf setFloat(int index, float value);

    public abstract ByteBuf setDouble(int index, double value);

   //从指定的index开始将指定源缓冲区的数据传输到此缓冲区，直到源缓冲区变得不可读为止。此方法与{@link#setBytes（int，ByteBuf，int，int）}基本相同，只是此方法将源缓冲区的{@code readerIndex}增加传输字节数，而{@link#setBytes（int，ByteBuf，int，int）}不增加。此方法不修改源缓冲区的{@code readerIndex}或{@code writerIndex}（即{@code This}）。
    public abstract ByteBuf setBytes(int index, ByteBuf src);

    public abstract ByteBuf setBytes(int index, ByteBuf src, int length);

    //从指定的index开始将指定源缓冲区的数据传输到此缓冲区。此方法不修改源（即{@code This}）和目标的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length);

    public abstract ByteBuf setBytes(int index, byte[] src);

    public abstract ByteBuf setBytes(int index, byte[] src, int srcIndex, int length);

    public abstract ByteBuf setBytes(int index, ByteBuffer src);

    public abstract int setBytes(int index, InputStream in, int length) throws IOException;

    public abstract int  setBytes(int index, ScatteringByteChannel in, int length) throws IOException;

   //从指定的index开始，用<tt>NUL（0x00）</tt>填充此缓冲区。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf setZero(int index, int length);

   //获取当前{@code readerIndex}处的布尔值，并在此缓冲区中将{@code readerIndex}增加{@code 1}。
    public abstract boolean readBoolean();

    public abstract byte  readByte();

    public abstract short readUnsignedByte();

    public abstract short readShort();

    public abstract int   readUnsignedShort();

    public abstract int   readMedium();

    public abstract int   readUnsignedMedium();

    public abstract int   readInt();

    public abstract long  readUnsignedInt();

    public abstract long  readLong();

    public abstract char  readChar();

    public abstract float readFloat();

    public abstract double readDouble();

    //将此缓冲区的数据传输到从当前{@code readerIndex}开始的新创建的缓冲区，并将{@code readerIndex}增加传输字节数（{@code length}）。返回的缓冲区{@code readerIndex}和{@code writerIndex}分别是{@code 0}和{@code length}。
    public abstract ByteBuf readBytes(int length);

    public abstract ByteBuf readSlice(int length);

    public abstract ByteBuf readBytes(ByteBuf dst);

    public abstract ByteBuf readBytes(ByteBuf dst, int length);

    public abstract ByteBuf readBytes(ByteBuf dst, int dstIndex, int length);

    public abstract ByteBuf readBytes(byte[] dst);

    public abstract ByteBuf readBytes(byte[] dst, int dstIndex, int length);

    public abstract ByteBuf readBytes(ByteBuffer dst);

    public abstract ByteBuf readBytes(OutputStream out, int length) throws IOException;

    public abstract int  readBytes(GatheringByteChannel out, int length) throws IOException;

    public abstract ByteBuf skipBytes(int length);

    public abstract ByteBuf writeBoolean(boolean value);

    public abstract ByteBuf writeByte(int value);

    public abstract ByteBuf writeShort(int value);

    public abstract ByteBuf writeMedium(int value);

    public abstract ByteBuf writeInt(int value);

    public abstract ByteBuf writeLong(long value);

    public abstract ByteBuf writeChar(int value);

    public abstract ByteBuf writeFloat(float value);

    public abstract ByteBuf writeDouble(double value);

    public abstract ByteBuf writeBytes(ByteBuf src);

    public abstract ByteBuf writeBytes(ByteBuf src, int length);

    public abstract ByteBuf writeBytes(ByteBuf src, int srcIndex, int length);

    public abstract ByteBuf writeBytes(byte[] src);

    public abstract ByteBuf writeBytes(byte[] src, int srcIndex, int length);

    public abstract ByteBuf writeBytes(ByteBuffer src);

    public abstract int  writeBytes(InputStream in, int length) throws IOException;

    public abstract int  writeBytes(ScatteringByteChannel in, int length) throws IOException;

    public abstract ByteBuf writeZero(int length);

    public abstract int indexOf(int fromIndex, int toIndex, byte value);

    public abstract int bytesBefore(byte value);

    public abstract int bytesBefore(int length, byte value);

   //定位此缓冲区中指定{@code value}的第一个匹配项。搜索从指定的{@code index}（包含）开始，并持续到指定的{@code length}。
  //此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract int bytesBefore(int index, int length, byte value);

    public abstract int forEachByte(ByteBufProcessor processor);

 
   //使用指定的{@code processor}按升序遍历此缓冲区的指定区域。（即{@code index}，{@code（index+1）}。。{@code（index+length-1）}
   //如果返回-1则处理器迭代到指定区域的末尾或之后。
   //如果{@link ByteBufProcessor{process（byte）}返回{@code false}，则返回上次访问的索引。
    public abstract int forEachByte(int index, int length, ByteBufProcessor processor);

    public abstract int forEachByteDesc(ByteBufProcessor processor);

    public abstract int forEachByteDesc(int index, int length, ByteBufProcessor processor);

    public abstract ByteBuf copy();

    //返回此缓冲区子区域的副本。修改返回缓冲区或此缓冲区的内容根本不会相互影响。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf copy(int index, int length);


    public abstract ByteBuf slice();


    public abstract ByteBuf slice(int index, int length);

  
     //返回共享此缓冲区的整个区域的缓冲区。修改返回缓冲区或此缓冲区的内容会影响彼此的内容，同时它们保持单独的索引和标记。此方法与{@code buf.slice（0，buf.capacity())}基本相同. 此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract ByteBuf duplicate();

    public abstract int nioBufferCount();

    public abstract ByteBuffer nioBuffer();

    public abstract ByteBuffer nioBuffer(int index, int length);

    public abstract ByteBuffer internalNioBuffer(int index, int length);

    public abstract ByteBuffer[] nioBuffers();

    //将此缓冲区的字节输出给指定索引的NIO{@link ByteBuffer}，返回的缓冲区与此缓冲区共享内容，而更改返回的NIO缓冲区的position和limit不会影响此缓冲区的索引和标记。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。请注意，如果返回的NIO缓冲区是动态缓冲区并调整了其容量，则返回的NIO缓冲区将看不到该缓冲区的更改。
    public abstract ByteBuffer[] nioBuffers(int index, int length);

    //是否支持备用数组
    public abstract boolean hasArray();

    //备用数组
    public abstract byte[] array();

    //返回此缓冲区的后备字节数组中第一个字节的偏移量。
    public abstract int arrayOffset();

     //返回{@code true}如果且仅当此缓冲区具有指向备份数据的低级内存地址的引用。
    public abstract boolean hasMemoryAddress();

   //返回指向备份数据的所在低级内存地址的第一个字节。
    public abstract long memoryAddress();

   //将此缓冲区的可读字节解码为具有指定字符集名称的字符串。此方法与{@code buf·toString(buf.readerIndex(), buf.readableBytes（），charset）}。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract String toString(Charset charset);

   //将此缓冲区的子区域解码为具有指定字符集的字符串。此方法不修改此缓冲区的{@code readerIndex}或{@code writerIndex}。
    public abstract String toString(int index, int length, Charset charset);

netty的ByteBufAllocator

负责分配buffer。这个接口的实现应该是线程安全的。


ByteBufAllocator
//一个final的属性引用
ByteBufAllocator DEFAULT = ByteBufUtil.DEFAULT_ALLOCATOR;

    api:

    //分配{@link ByteBuf}。它是直接缓冲区还是堆缓冲区取决于实际的实现。
    ByteBuf buffer();

    //用给定的初始容量分配{@link ByteBuf}。它是直接缓冲区还是堆缓冲区取决于实际的实现。
    ByteBuf buffer(int initialCapacity);

    //用给定的初始容量和最大容量分配{@link ByteBuf}。它是直接缓冲区还是堆缓冲区取决于实际的实现。
    ByteBuf buffer(int initialCapacity, int maxCapacity);

    //分配{@link ByteBuf}，最好是一个direct buffer，因为直接缓存更适合I/O操作。
    //一半这个方法实现，也都是new 一个直接buffer
    ByteBuf ioBuffer();

    ByteBuf ioBuffer(int initialCapacity);

    ByteBuf ioBuffer(int initialCapacity, int maxCapacity);




    //分配堆{@link ByteBuf}。
    ByteBuf heapBuffer(); //底层就是堆内存的数组
    ByteBuf heapBuffer(int initialCapacity);
    ByteBuf heapBuffer(int initialCapacity, int maxCapacity);

     //分配一个直接缓存 Bytebuf
   //底层就是 ByteBuffer.allocateDirect(int capacity)，UNSAFE.allocateMemory(size);
    ByteBuf directBuffer(); 
    ByteBuf directBuffer(int initialCapacity);
    ByteBuf directBuffer(int initialCapacity, int maxCapacity);

    //分配{@link CompositeByteBuf}。它是直接缓冲区还是堆缓冲区取决于实际的实现。
    //CompositeByteBuf有组合能力
    CompositeByteBuf compositeBuffer();

    //分配一个{@link CompositeByteBuf}，其中可以存储  指定的最大组件数。
    CompositeByteBuf compositeBuffer(int maxNumComponents);

    //堆缓存
    CompositeByteBuf compositeHeapBuffer();

    CompositeByteBuf compositeHeapBuffer(int maxNumComponents);

    //直接缓存
    CompositeByteBuf compositeDirectBuffer();

    CompositeByteBuf compositeDirectBuffer(int maxNumComponents);

    //如果返回{@code true}，则直接缓存{@link ByteBuf}是池化的，
    boolean isDirectBufferPooled();

netty的UnpooledByteBufAllocator

UnpooledByteBufAllocator

简单化的{@link  bytebuffallocator}实现，它没有 （池化）pool 任何内容。

     private final boolean disableLeakDetector;//是否检测内存泄漏，fasle启用泄漏检测

    //对直接缓冲区使用泄漏检测的默认实例。
    public static final UnpooledByteBufAllocator DEFAULT =
            new UnpooledByteBufAllocator(PlatformDependent.directBufferPreferred());

    //创建一个对直接缓冲区使用泄漏检测的新实例。
    public UnpooledByteBufAllocator(boolean preferDirect) {
        this(preferDirect, false);
    }
   //preferDirect这个参数解释看下面一段代码
   /*
    public ByteBuf buffer() {
        if (directByDefault) {
            return directBuffer();
        }
        return heapBuffer();
    }
   
   */
 
泄漏检测包装
 protected static ByteBuf toLeakAwareBuffer(ByteBuf buf) {
        ResourceLeak leak;
        switch (ResourceLeakDetector.getLevel()) {
            case SIMPLE:
                leak = AbstractByteBuf.leakDetector.open(buf);
                if (leak != null) {
                    buf = new SimpleLeakAwareByteBuf(buf, leak);
                }
                break;
            case ADVANCED:
            case PARANOID:
                leak = AbstractByteBuf.leakDetector.open(buf);
                if (leak != null) {
                    buf = new AdvancedLeakAwareByteBuf(buf, leak);
                }
                break;
        }
        return buf;
    }

netty的PooledByteBufAllocator

PooledByteBufAllocator

     //默认实例
     public static final PooledByteBufAllocator DEFAULT =
            new PooledByteBufAllocator(PlatformDependent.directBufferPreferred());


    private static final int MIN_PAGE_SIZE = 4096;
    private static final int MAX_CHUNK_SIZE = (int) (((long) Integer.MAX_VALUE + 1) / 2);

    static {
        int defaultPageSize = SystemPropertyUtil.getInt("io.netty.allocator.pageSize", 8192); //默认页大小 8192
        Throwable pageSizeFallbackCause = null;
        try {
            //defaultPageSize必须大于等于MIN_PAGE_SIZE，必须是2的次幂
            validateAndCalculatePageShifts(defaultPageSize);
        } catch (Throwable t) {
            pageSizeFallbackCause = t;
            defaultPageSize = 8192;
        }
        DEFAULT_PAGE_SIZE = defaultPageSize;

        int defaultMaxOrder = SystemPropertyUtil.getInt("io.netty.allocator.maxOrder", 11);// 11
        Throwable maxOrderFallbackCause = null;
        try {
            //defaultMaxOrder必须小于等于14，DEFAULT_PAGE_SIZE左移defaultMaxOrder必须小于等于2的30次方，1G
            //避免ChunkSize的值 超过1G大小
            validateAndCalculateChunkSize(DEFAULT_PAGE_SIZE, defaultMaxOrder);
        } catch (Throwable t) {
            maxOrderFallbackCause = t;
            defaultMaxOrder = 11;
        }
        DEFAULT_MAX_ORDER = defaultMaxOrder;

        
        final Runtime runtime = Runtime.getRuntime();

        //默认情况下，使用2*cpu核数，因为我们使用2*cpu核数来计算EventLoop的数量
        //PoolArena这个热点数据分配和释放需要同步。所以线程争用是必须的，为了减少线程争用和减少线程上下文的切换，所以默认最小的area个数就是 2*cpu核数
        
        final int defaultMinNumArena = runtime.availableProcessors() * 2;
        final int defaultChunkSize = DEFAULT_PAGE_SIZE << DEFAULT_MAX_ORDER;
        
         //为nHeapArena和nDirectArena确定合理的默认值。
         //假设每个arena有3个块(chunk)，池子总共arena消耗的内存不应超过最大内存的50%。
        DEFAULT_NUM_HEAP_ARENA = Math.max(0,
                SystemPropertyUtil.getInt(
                        "io.netty.allocator.numHeapArenas",
                        (int) Math.min(
                                defaultMinNumArena,
                                runtime.maxMemory() / defaultChunkSize / 2 / 3)));
        DEFAULT_NUM_DIRECT_ARENA = Math.max(0,
                SystemPropertyUtil.getInt(
                        "io.netty.allocator.numDirectArenas",
                        (int) Math.min(
                                defaultMinNumArena,
                                PlatformDependent.maxDirectMemory() / defaultChunkSize / 2 / 3)));

        // cache sizes 分而治之
        DEFAULT_TINY_CACHE_SIZE = SystemPropertyUtil.getInt("io.netty.allocator.tinyCacheSize", 512);
        DEFAULT_SMALL_CACHE_SIZE = SystemPropertyUtil.getInt("io.netty.allocator.smallCacheSize", 256);
        DEFAULT_NORMAL_CACHE_SIZE = SystemPropertyUtil.getInt("io.netty.allocator.normalCacheSize", 64);

        //32 kb是cached缓冲区的默认最大容量。类似于“使用jemalloc的可伸缩内存分配”中的解释
        DEFAULT_MAX_CACHED_BUFFER_CAPACITY = SystemPropertyUtil.getInt(
                "io.netty.allocator.maxCachedBufferCapacity", 32 * 1024);
        //如果不经常使用，将释放缓存项时的分配阈值数
        DEFAULT_CACHE_TRIM_INTERVAL = SystemPropertyUtil.getInt(
                "io.netty.allocator.cacheTrimInterval", 8192);

    }

    public PooledByteBufAllocator(boolean preferDirect, int nHeapArena, int nDirectArena, int pageSize, int maxOrder,
                                  int tinyCacheSize, int smallCacheSize, int normalCacheSize) {
        super(preferDirect);
        threadCache = new PoolThreadLocalCache();
        this.tinyCacheSize = tinyCacheSize;
        this.smallCacheSize = smallCacheSize;
        this.normalCacheSize = normalCacheSize;
        final int chunkSize = validateAndCalculateChunkSize(pageSize, maxOrder);
        int pageShifts = validateAndCalculatePageShifts(pageSize);

        
        
        
        if (nHeapArena > 0) {
            heapArenas = newArenaArray(nHeapArena);
            List<PoolArenaMetric> metrics = new ArrayList<PoolArenaMetric>(heapArenas.length);
            for (int i = 0; i < heapArenas.length; i ++) {
                //这里是重点
                PoolArena.HeapArena arena = new PoolArena.HeapArena(this, pageSize, maxOrder, pageShifts, chunkSize);
                heapArenas[i] = arena;
                metrics.add(arena);
            }
            heapArenaMetrics = Collections.unmodifiableList(metrics);
        } else {
            heapArenas = null;
            heapArenaMetrics = Collections.emptyList();
        }

        if (nDirectArena > 0) {
            directArenas = newArenaArray(nDirectArena);
            List<PoolArenaMetric> metrics = new ArrayList<PoolArenaMetric>(directArenas.length);
            for (int i = 0; i < directArenas.length; i ++) {
                 //这里是重点
                PoolArena.DirectArena arena = new PoolArena.DirectArena(
                        this, pageSize, maxOrder, pageShifts, chunkSize);
                directArenas[i] = arena;
                metrics.add(arena);
            }
            directArenaMetrics = Collections.unmodifiableList(metrics);
        } else {
            directArenas = null;
            directArenaMetrics = Collections.emptyList();
        }
    }

1593192524248

netty的PoolArenaMetric


PoolArenaMetric 
    /*
    暴露一个 arena的指标，（测量这一个arena）。
    
    */
    api: 
    int numTinySubpages();//返回这个arena的tiny 子页数

    int numSmallSubpages();//返回这个arena的small 子页数

    int numChunkLists();//返回这个arena的chunklist个数

    List<PoolSubpageMetric> tinySubpages();//返回一个不可修改的{@link List}，其中包含用于tiny sub-pages的{@link PoolSubpageMetric}。

    List<PoolSubpageMetric> smallSubpages();//返回一个不可修改的{@link List}，其中包含用于 small sub-pages的{@link PoolSubpageMetric}。

    List<PoolChunkListMetric> chunkLists();//返回一个不可修改的{@link List}，其中包含{@link PoolChunkListMetric}。

    long numAllocations();//返回通过arena完成的分配数。这包括所有尺寸。

    long numTinyAllocations();//返回通过arena完成的tiny的分配数。

    long numSmallAllocations();//返回通过arena完成的small的分配数。

    long numNormalAllocations();//返回通过arena完成的normal的分配数。

    long numHugeAllocations();//返回通过arena完成的huge的分配数。

    long numDeallocations();//返回通过arena完成的deallocations数量。这包括所有尺寸。

    long numTinyDeallocations();//返回通过arena完成的tiniy的deallocations数量。这包括所有尺寸。

    long numSmallDeallocations();//返回通过arena完成的small的deallocations数量。

    long numNormalDeallocations();//返回通过arena完成的normal的deallocations数量

    long numHugeDeallocations();//返回通过arena完成的huge的deallocations数量

    long numActiveAllocations();//返回当前活动分配数。

    long numActiveTinyAllocations();//返回当前活动的tiny分配数。

    long numActiveSmallAllocations();//返回当前活动的small分配数。

    long numActiveNormalAllocations();//返回当前活动的normal分配数。

    long numActiveHugeAllocations();//返回当前活动的huge分配数。

    long numActiveBytes();//返回arena当前分配的活动字节数。

netty的PoolArena


    
    
    
PoolArena  继承 PoolArenaMetric
     static final boolean HAS_UNSAFE = PlatformDependent.hasUnsafe();//是否有unsafe支持
        static final int numTinySubpagePools = 512 >>> 4;//32

enum SizeClass {
        Tiny,
        Small,
        Normal
    }
    
    
protected PoolArena(PooledByteBufAllocator parent, int pageSize, int maxOrder, int pageShifts, int chunkSize) {
        this.parent = parent;
        this.pageSize = pageSize;
        this.maxOrder = maxOrder;
        this.pageShifts = pageShifts;
        this.chunkSize = chunkSize;
        subpageOverflowMask = ~(pageSize - 1);
        tinySubpagePools = newSubpagePoolArray(numTinySubpagePools);
        for (int i = 0; i < tinySubpagePools.length; i ++) {
            tinySubpagePools[i] = newSubpagePoolHead(pageSize);
        }

        numSmallSubpagePools = pageShifts - 9;
        smallSubpagePools = newSubpagePoolArray(numSmallSubpagePools);
        for (int i = 0; i < smallSubpagePools.length; i ++) {
            smallSubpagePools[i] = newSubpagePoolHead(pageSize);
        }

        //qInit-->q000-->q025-->q050-->q075-->q100
        q100 = new PoolChunkList<T>(null, 100, Integer.MAX_VALUE, chunkSize);
        q075 = new PoolChunkList<T>(q100, 75, 100, chunkSize);
        q050 = new PoolChunkList<T>(q075, 50, 100, chunkSize);
        q025 = new PoolChunkList<T>(q050, 25, 75, chunkSize);
        q000 = new PoolChunkList<T>(q025, 1, 50, chunkSize);
        qInit = new PoolChunkList<T>(q000, Integer.MIN_VALUE, 25, chunkSize);
        //qInit<--q000<--q025<--q050<--q075<--q100
        q100.prevList(q075);
        q075.prevList(q050);
        q050.prevList(q025);
        q025.prevList(q000);
        q000.prevList(null);
        qInit.prevList(qInit);
        //这样q100 到 qinit就是一个双向链表

        List<PoolChunkListMetric> metrics = new ArrayList<PoolChunkListMetric>(6);
        metrics.add(qInit);
        metrics.add(q000);
        metrics.add(q025);
        metrics.add(q050);
        metrics.add(q075);
        metrics.add(q100);
        chunkListMetrics = Collections.unmodifiableList(metrics);
        //chunkListMetrics把 q100到 qInit装起来
    }

netty的 PoolChunk

PoolChunkMetric
    /*
    测量一个 chunk的
    */
    api:
       int usage();//返回块当前使用率的百分比。
    /**
     * Return the size of the chunk in bytes, this is the maximum of bytes that can be served out of the chunk.
     */
       int chunkSize();//返回以字节为单位的块大小，这是可以从块中服务的最大字节数。

       int freeBytes();//返回块中的可用字节数。
    
PoolChunk<T>  
/*
PoolChunk中PageRun/PoolSubpage分配算法描述:
     以下术语对于理解代码很重要 :
          > page  -  页是可以分配的最小内存块单元
          > chunk - chunk是page的集合
          在此代码中，chunkSize=2^{maxOrder}*pageSize
     首先，当需要创建给定大小的ByteBuf时，我们分配一个size=chunkSize的字节数组，在字节数组中搜索第一个有足够的空空间来 容纳请求的分配大小的  位置，并返回一个（long类型）句柄来编码该偏移量信息（然后将该内存段标记为保留，因此它总是仅由一个ByteBuf使用，不再使用这段内存用于内存分配）  
    为了简单起见，所有大小都根据PoolArena#normalizeCapacity方法进行了规范化，这确保当我们请求size>=pageSize的内存段时，normalizedpacity等于2的下一个最接近的幂  
    为了搜索块中至少有请求大小可用的第一个偏移量，我们构造了一个完整的平衡二叉树，并将其存储在一个数组（就像堆一样）-内存映射中   
    树看起来是这样的（括号中提到的每个节点的大小）：
 * depth=0        1 node (chunkSize)
 * depth=1        2 nodes (chunkSize/2)
 * ..
 * ..
 * depth=d        2^d nodes (chunkSize/2^d)
 * ..
 * depth=maxOrder 2^maxOrder nodes (chunkSize/2^{maxOrder} = pageSize)
 * 
 * depth=maxOrder is the last level and the leafs consist of pages
 
     使用此树在chunkArray中进行搜索时，转换如下：
     要分配大小为chunkSize/2^k的内存段，我们在高度k处搜索第一个未使用的节点（从左开始）
     算法：
        用符号将树编码在内存中
        memoryMap[id]=x => 在以id为根的子树中，第一个可自由分配的节点位于深度x（从深度=0开始计算），即在深度[depth_of_id，x]处，没有可自由分配的节点
        当我们分配空闲节点时，我们更新存储在memoryMap中的值，以便维护属性
     初始化：
       首先，我们通过存储每个节点的节点深度来构造memoryMap数组，即memoryMap[id]=depth_of_id
 * 观察:
 * -------------
 * 1) memoryMap[id] = depth_of_id  => it is free / unallocated
 * 2) memoryMap[id] > depth_of_id  =>至少有一个子节点被分配了，所以我们不能分配它，但是它的一些子节点仍然可以根据它们的可用性进行分配
 * 3) memoryMap[id] = maxOrder + 1 => 节点已完全分配，因此无法分配其子节点，因此将其标记为不可用
 *
 * Algorithm: [allocateNode(d) =>我们想在高度h处找到第一个节点（从左起），它可以被分配]
 * ----------
 * 1) 从根部开始（即深度=0或id=1）
 * 2) if memoryMap[1] > d => 无法从此块中分配
 * 3) if left node value <= h; 我们可以从左子树开始分配，所以向左移动并重复直到找到
 * 4) else try in right subtree（右子树分配）
 *
 * Algorithm: [allocateRun(size)]
 * ----------
 * 1) Compute d = log_2(chunkSize/size)
 * 2) Return allocateNode(d)
 *
 * Algorithm: [allocateSubpage(size)]
 * ----------
 * 1) use allocateNode(maxOrder) to find an empty (i.e., unused) leaf (i.e., page)
 * 2) use this handle to construct the PoolSubpage object or if it already exists just call init(normCapacity)
 *    note that this PoolSubpage object is added to subpagesPool in the PoolArena when we init() it
 *
 * Note:
 * -----
 * 在提高缓存一致性的实现中，我们将2条信息（即2字节vals）作为一个短值存储在memoryMap中
 *
 * memoryMap[id]= (depth_of_id, x)
 * 其中，根据上面定义的约定，第二个值（即x）表示第一个可自由分配的节点位于深度x（从根）
    
*/

netty的PoolChunkListMetric



/**
 * Metrics for a list of chunks.
 */
public interface PoolChunkListMetric extends Iterable<PoolChunkMetric> {

    int minUsage();//返回chunk列表的最小使用量，在此之前chunk 将提升到上一个列表。

    int maxUsage();//返回chunk列表的最小使用量，在此之后chunk将提升到下一个列表。
}

内存分配算法

有点难，等有时间去详细看 buddy 伙伴内存分配算法

本文作者： 忘忧症
本文链接： https://NepenthesZGW.github.io/2020/06/25/framework/Netty/netty重要名词/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！