Netty的那点事儿

时间 2019-11-08

标签 netty 那点事儿栏目 Netty 繁體版

原文原文链接

Netty是一个基于异步与事件驱动的网络应用程序框架，它支持快速与简单地开发可维护的高性能的服务器与客户端。html

所谓事件驱动就是由经过各类事件响应来决定程序的流程，在Netty中处处都充满了异步与事件驱动，这种特色使得应用程序能够以任意的顺序响应在任意的时间点产生的事件，它带来了很是高的可伸缩性，让你的应用能够在须要处理的工做不断增加时，经过某种可行的方式或者扩大它的处理能力来适应这种增加。java

Netty提供了高性能与易用性，它具备如下特色：linux

拥有设计良好且统一的API，支持NIO与OIO（阻塞IO）等多种传输类型，支持真正的无链接UDP Socket。c++
简单而强大的线程模型，可高度定制线程（池）。git
良好的模块化与解耦，支持可扩展和灵活的事件模型，能够很轻松地分离关注点以复用逻辑组件（可插拔的）。github
性能高效，拥有比Java核心API更高的吞吐量，经过zero-copy功能以实现最少的内存复制消耗。算法
内置了许多经常使用的协议编解码器，如HTTP、SSL、WebScoket等常见协议能够经过Netty作到开箱即用。用户也能够利用Netty简单方便地实现本身的应用层协议。编程

大多数人使用Netty主要仍是为了提升应用的性能，而高性能则离不开非阻塞IO。Netty的非阻塞IO是基于Java NIO的，而且对其进行了封装（直接使用Java NIO API在高复杂度下的应用中是一项很是繁琐且容易出错的操做，而Netty帮你封装了这些复杂操做）。api

NIO能够称为New IO也能够称为Non-blocking IO，它比Java旧的阻塞IO在性能上要高效许多（若是让每个链接中的IO操做都单首创建一个线程，那么阻塞IO并不会比NIO在性能上落后，但不可能建立无限多的线程，在链接数很是多的状况下会很糟糕）。数组

ByteBuffer：NIO的数据传输是基于缓冲区的，ByteBuffer正是NIO数据传输中所使用的缓冲区抽象。ByteBuffer支持在堆外分配内存，而且尝试避免在执行I/O操做中的多余复制。通常的I/O操做都须要进行系统调用，这样会先切换到内核态，内核态要先从文件读取数据到它的缓冲区，只有等数据准备完毕后，才会从内核态把数据写到用户态，所谓的阻塞IO其实就是说的在等待数据准备好的这段时间内进行阻塞。若是想要避免这个额外的内核操做，能够经过使用mmap（虚拟内存映射）的方式来让用户态直接操做文件。
Channel：它相似于文件描述符，简单地来讲它表明了一个实体（如一个硬件设备、文件、Socket或者一个可以执行一个或多个不一样的I/O操做的程序组件）。你能够从一个Channel中读取数据到缓冲区，也能够将一个缓冲区中的数据写入到Channel。
Selector：选择器是NIO实现的关键，NIO采用的是I/O多路复用的方式来实现非阻塞，Selector经过在一个线程中监听每一个Channel的IO事件来肯定有哪些已经准备好进行IO操做的Channel，所以能够在任什么时候间检查任意的读操做或写操做的完成状态。这种方式避免了等待IO操做准备数据时的阻塞，使用较少的线程即可以处理许多链接，减小了线程切换与维护的开销。

了解了NIO的实现思想以后，我以为还颇有必要了解一下Unix中的I/O模型，Unix中拥有如下5种I/O模型：

阻塞I/O（Blocking I/O）
非阻塞I/O（Non-blocking I/O）
I/O多路复用（I/O multiplexing (select and poll)）
信号驱动I/O（signal driven I/O (SIGIO)）
异步I/O（asynchronous I/O (the POSIX aio_functions)）

阻塞I/O模型是最多见的I/O模型，一般咱们使用的InputStream/OutputStream都是基于阻塞I/O模型。在上图中，咱们使用UDP做为例子，recvfrom()函数是UDP协议用于接收数据的函数，它须要使用系统调用并一直阻塞到内核将数据准备好，以后再由内核缓冲区复制数据到用户态（便是recvfrom()接收到数据），所谓阻塞就是在等待内核准备数据的这段时间内什么也不干。

举个生活中的例子，阻塞I/O就像是你去餐厅吃饭，在等待饭作好的时间段中，你只能在餐厅中坐着干等（若是你在玩手机那么这就是非阻塞I/O了）。

在非阻塞I/O模型中，内核在数据还没有准备好的状况下回返回一个错误码EWOULDBLOCK，而recvfrom并无在失败的状况下选择阻塞休眠，而是不断地向内核询问是否已经准备完毕，在上图中，前三次内核都返回了EWOULDBLOCK，直到第四次询问时，内核数据准备完毕，而后开始将内核中缓存的数据复制到用户态。这种不断询问内核以查看某种状态是否完成的方式被称为polling（轮询）。

非阻塞I/O就像是你在点外卖，只不过你很是心急，每隔一段时间就要打电话问外卖小哥有没有到。

I/O多路复用的思想跟非阻塞I/O是同样的，只不过在非阻塞I/O中，是在recvfrom的用户态（或一个线程）中去轮询内核，这种方式会消耗大量的CPU时间。而I/O多路复用则是经过select()或poll()系统调用来负责进行轮询，以实现监听I/O读写事件的状态。如上图中，select监听到一个datagram可读时，就交由recvfrom去发送系统调用将内核中的数据复制到用户态。

这种方式的优势很明显，经过I/O多路复用能够监听多个文件描述符，且在内核中完成监控的任务。但缺点是至少须要两个系统调用（select()与recvfrom()）。

I/O多路复用一样适用于点外卖这个例子，只不过你在等外卖的期间彻底能够作本身的事情，当外卖到的时候会经过外卖APP或者由外卖小哥打电话来通知你。

Unix中提供了两种I/O多路复用函数，select()和poll()。select()的兼容性更好，但它在单个进程中所能监控的文件描述符是有限的，这个值与FD_SETSIZE相关，32位系统中默认为1024，64位系统中为2048。select()还有一个缺点就是他轮询的方式，它采起了线性扫描的轮询方式，每次都要遍历FD_SETSIZE个文件描述符，无论它们是否活不活跃的。poll()本质上与select()的实现没有区别，不过在数据结构上区别很大，用户必须分配一个pollfd结构数组，该数组维护在内核态中，正因如此，poll()并不像select()那样拥有大小上限的限制，但缺点一样也很明显，大量的fd数组会在用户态与内核态之间不断复制，无论这样的复制是否有意义。

还有一种比select()与poll()更加高效的实现叫作epoll()，它是由Linux内核2.6推出的可伸缩的I/O多路复用实现，目的是为了替代select()与poll()。epoll()一样没有文件描述符上限的限制，它使用一个文件描述符来管理多个文件描述符，并使用一个红黑树来做为存储结构。同时它还支持边缘触发（edge-triggered）与水平触发（level-triggered）两种模式（poll()只支持水平触发），在边缘触发模式下，epoll_wait仅会在新的事件对象首次被加入到epoll时返回，而在水平触发模式下，epoll_wait会在事件状态未变动前不断地触发。也就是说，边缘触发模式只会在文件描述符变为就绪状态时通知一次，水平触发模式会不断地通知该文件描述符直到被处理。

关于epoll_wait请参考以下epoll API。

// 建立一个epoll对象并返回它的文件描述符。
// 参数flags容许修改epoll的行为，它只有一个有效值EPOLL_CLOEXEC。
int epoll_create1(int flags);

// 配置对象，该对象负责描述监控哪些文件描述符和哪些事件。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

// 等待与epoll_ctl注册的任何事件，直至事件发生一次或超时。
// 返回在events中发生的事件，最多同时返回maxevents个。
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
复制代码

epoll另外一亮点是采用了事件驱动的方式而不是轮询，在epoll_ctl中注册的文件描述符在事件触发的时候会经过一个回调机制来激活该文件描述符，epoll_wait即可以收到通知。这样效率就不会与文件描述符的数量成正比。epoll还采用了mmap来减小内核态与用户态之间的数据传输开销。

在Java NIO2（从JDK1.7开始引入）中，只要Linux内核版本在2.6以上，就会采用epoll，以下源码所示（DefaultSelectorProvider.java）。

public static SelectorProvider create() {
    String osname = AccessController.doPrivileged(
        new GetPropertyAction("os.name"));
    if ("SunOS".equals(osname)) {
        return new sun.nio.ch.DevPollSelectorProvider();
    }

    // use EPollSelectorProvider for Linux kernels >= 2.6
    if ("Linux".equals(osname)) {
        String osversion = AccessController.doPrivileged(
            new GetPropertyAction("os.version"));
        String[] vers = osversion.split("\\.", 0);
        if (vers.length >= 2) {
            try {
                int major = Integer.parseInt(vers[0]);
                int minor = Integer.parseInt(vers[1]);
                if (major > 2 || (major == 2 && minor >= 6)) {
                    return new sun.nio.ch.EPollSelectorProvider();
                }
            } catch (NumberFormatException x) {
                // format not recognized
            }
        }
    }

    return new sun.nio.ch.PollSelectorProvider();
}
复制代码

信号驱动I/O模型使用到了信号，内核在数据准备就绪时会经过信号来进行通知。咱们首先开启了一个信号驱动I/O套接字，并使用sigaction系统调用来安装信号处理程序，内核直接返回，不会阻塞用户态。当datagram准备好时，内核会发送SIGIO信号，recvfrom接收到信号后会发送系统调用开始进行I/O操做。

这种模型的优势是主进程（线程）不会被阻塞，当数据准备就绪时，经过信号处理程序来通知主进程（线程）准备进行I/O操做与对数据的处理。

咱们以前讨论的各类I/O模型不管是阻塞仍是非阻塞，它们所说的阻塞都是指的数据准备阶段。异步I/O模型一样依赖于信号处理程序来进行通知，但与以上I/O模型都不相同的是，异步I/O模型通知的是I/O操做已经完成，而不是数据准备完成。

能够说异步I/O模型才是真正的非阻塞，主进程只管作本身的事情，而后在I/O操做完成时调用回调函数来完成一些对数据的处理操做便可。

闲扯了这么多，想必你们已经对I/O模型有了一个深入的认识。以后，咱们将会结合部分源码（Netty4.X）来探讨Netty中的各大核心组件，以及如何使用Netty，你会发现实现一个Netty程序是多么简单（并且还伴随了高性能与可维护性）。

本文做者为SylvanasSun(sylvanas.sun@gmail.com)，首发于SylvanasSun’s Blog。原文连接：https://sylvanassun.github.io/2017/11/30/2017-11-30-netty_introduction/ （转载请务必保留本段声明，而且保留超连接。）

ByteBuf

网络传输的基本单位是字节，在Java NIO中提供了ByteBuffer做为字节缓冲区容器，但该类的API使用起来不太方便，因此Netty实现了ByteBuf做为其替代品，下面是使用ByteBuf的优势：

相比ByteBuffer使用起来更加简单。
经过内置的复合缓冲区类型实现了透明的zero-copy。
容量能够按需增加。
读和写使用了不一样的索引指针。
支持链式调用。
支持引用计数与池化。
能够被用户自定义的缓冲区类型扩展。

在讨论ByteBuf以前，咱们先须要了解一下ByteBuffer的实现，这样才能比较深入地明白它们之间的区别。

ByteBuffer继承于abstract class Buffer（因此还有LongBuffer、IntBuffer等其余类型的实现），本质上它只是一个有限的线性的元素序列，包含了三个重要的属性。

Capacity：缓冲区中元素的容量大小，你只能将capacity个数量的元素写入缓冲区，一旦缓冲区已满就须要清理缓冲区才能继续写数据。
Position：指向下一个写入数据位置的索引指针，初始位置为0，最大为capacity-1。当写模式转换为读模式时，position须要被重置为0。
Limit：在写模式中，limit是能够写入缓冲区的最大索引，也就是说它在写模式中等价于缓冲区的容量。在读模式中，limit表示能够读取数据的最大索引。

因为Buffer中只维护了position一个索引指针，因此它在读写模式之间的切换须要调用一个flip()方法来重置指针。使用Buffer的流程通常以下：

写入数据到缓冲区。
调用flip()方法。
从缓冲区中读取数据
调用buffer.clear()或者buffer.compact()清理缓冲区，以便下次写入数据。

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();

// 分配一个48字节大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(48);

int bytesRead = inChannel.read(buf); // 读取数据到缓冲区
while (bytesRead != -1) {

  buf.flip();  // 将position重置为0

  while(buf.hasRemaining()){
      System.out.print((char) buf.get()); // 读取数据并输出到控制台
  }

  buf.clear(); // 清理缓冲区
  bytesRead = inChannel.read(buf);
}
aFile.close();
复制代码

Buffer中核心方法的实现也很是简单，主要就是在操做指针position。

/** * Sets this buffer's mark at its position. * * @return This buffer */
    public final Buffer mark() {
        mark = position; // mark属性是用来标记当前索引位置的
        return this;
    }
	
	// 将当前索引位置重置为mark所标记的位置
    public final Buffer reset() {
        int m = mark;
        if (m < 0)
            throw new InvalidMarkException();
        position = m;
        return this;
    }	

	// 翻转这个Buffer，将limit设置为当前索引位置，而后再把position重置为0
    public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }
	
	// 清理缓冲区
	// 说是清理,也只是把postion与limit进行重置,以后再写入数据就会覆盖以前的数据了
    public final Buffer clear() {
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
    }
	
	// 返回剩余空间
    public final int remaining() {
        return limit - position;
    }
复制代码

Java NIO中的Buffer API操做的麻烦之处就在于读写转换须要手动重置指针。而ByteBuf没有这种繁琐性，它维护了两个不一样的索引，一个用于读取，一个用于写入。当你从ByteBuf读取数据时，它的readerIndex将会被递增已经被读取的字节数，一样的，当你写入数据时，writerIndex则会递增。readerIndex的最大范围在writerIndex的所在位置，若是试图移动readerIndex超过该值则会触发异常。

ByteBuf中名称以read或write开头的方法将会递增它们其对应的索引，而名称以get或set开头的方法则不会。ByteBuf一样能够指定一个最大容量，试图移动writerIndex超过该值则会触发异常。

public byte readByte() {
        this.checkReadableBytes0(1); // 检查readerIndex是否已越界
        int i = this.readerIndex;
        byte b = this._getByte(i);
        this.readerIndex = i + 1; // 递增readerIndex
        return b;
    }

    private void checkReadableBytes0(int minimumReadableBytes) {
        this.ensureAccessible();
        if(this.readerIndex > this.writerIndex - minimumReadableBytes) {
            throw new IndexOutOfBoundsException(String.format("readerIndex(%d) + length(%d) exceeds writerIndex(%d): %s", new Object[]{Integer.valueOf(this.readerIndex), Integer.valueOf(minimumReadableBytes), Integer.valueOf(this.writerIndex), this}));
        }
    }
	
    public ByteBuf writeByte(int value) {
        this.ensureAccessible();
        this.ensureWritable0(1); // 检查writerIndex是否会越过capacity
        this._setByte(this.writerIndex++, value);
        return this;
    }
	
    private void ensureWritable0(int minWritableBytes) {
        if(minWritableBytes > this.writableBytes()) {
            if(minWritableBytes > this.maxCapacity - this.writerIndex) {
                throw new IndexOutOfBoundsException(String.format("writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s", new Object[]{Integer.valueOf(this.writerIndex), Integer.valueOf(minWritableBytes), Integer.valueOf(this.maxCapacity), this}));
            } else {
                int newCapacity = this.alloc().calculateNewCapacity(this.writerIndex + minWritableBytes, this.maxCapacity);
                this.capacity(newCapacity);
            }
        }
    }	
	
	// get与set只对传入的索引进行了检查，而后对其位置进行get或set 
    public byte getByte(int index) {
        this.checkIndex(index);
        return this._getByte(index);
    }

    public ByteBuf setByte(int index, int value) {
        this.checkIndex(index);
        this._setByte(index, value);
        return this;
    }
复制代码

ByteBuf一样支持在堆内和堆外进行分配。在堆内分配也被称为支撑数组模式，它能在没有使用池化的状况下提供快速的分配和释放。

ByteBuf heapBuf = Unpooled.copiedBuffer(bytes);
	if (heapBuf.hasArray()) { // 判断是否有一个支撑数组
		byte[] array = heapBuf.array();
		// 计算第一个字节的偏移量
		int offset = heapBuf.arrayOffset() + heapBuf.readerIndex();
		int length = heapBuf.readableBytes(); // 得到可读字节
		handleArray(array,offset,length); // 调用你的处理方法
	}
复制代码

另外一种模式为堆外分配，Java NIO ByteBuffer类在JDK1.4时就已经容许JVM实现经过JNI调用来在堆外分配内存（调用malloc()函数在JVM堆外分配内存），这主要是为了不额外的缓冲区复制操做。

ByteBuf directBuf = Unpooled.directBuffer(capacity);
	if (!directBuf.hasArray()) {
		int length = directBuf.readableBytes();
		byte[] array = new byte[length];
		// 将字节复制到数组中
		directBuf.getBytes(directBuf.readerIndex(),array);
		handleArray(array,0,length);
	}
复制代码

ByteBuf还支持第三种模式，它被称为复合缓冲区，为多个ByteBuf提供了一个聚合视图。在这个视图中，你能够根据须要添加或者删除ByteBuf实例，ByteBuf的子类CompositeByteBuf实现了该模式。

一个适合使用复合缓冲区的场景是HTTP协议，经过HTTP协议传输的消息都会被分红两部分——头部和主体，若是这两部分由应用程序的不一样模块产生，将在消息发送时进行组装，而且该应用程序还会为多个消息复用相同的消息主体，这样对于每一个消息都将会建立一个新的头部，产生了不少没必要要的内存操做。使用CompositeByteBuf是一个很好的选择，它消除了这些额外的复制，以帮助你复用这些消息。

CompositeByteBuf messageBuf = Unpooled.compositeBuffer();
	ByteBuf headerBuf = ....;
	ByteBuf bodyBuf = ....;
	messageBuf.addComponents(headerBuf,bodyBuf);
	for (ByteBuf buf : messageBuf) {
		System.out.println(buf.toString());
	}
复制代码

CompositeByteBuf透明的实现了zero-copy，zero-copy其实就是避免数据在两个内存区域中来回的复制。从操做系统层面上来说，zero-copy指的是避免在内核态与用户态之间的数据缓冲区复制（经过mmap避免），而Netty中的zero-copy更偏向于在用户态中的数据操做的优化，就像使用CompositeByteBuf来复用多个ByteBuf以免额外的复制，也可使用wrap()方法来将一个字节数组包装成ByteBuf，又或者使用ByteBuf的slice()方法把它分割为多个共享同一内存区域的ByteBuf，这些都是为了优化内存的使用率。

那么如何建立ByteBuf呢？在上面的代码中使用到了Unpooled，它是Netty提供的一个用于建立与分配ByteBuf的工具类，建议都使用这个工具类来建立你的缓冲区，不要本身去调用构造函数。常用的是wrappedBuffer()与copiedBuffer()，它们一个是用于将一个字节数组或ByteBuffer包装为一个ByteBuf，一个是根据传入的字节数组与ByteBuffer/ByteBuf来复制出一个新的ByteBuf。

// 经过array.clone()来复制一个数组进行包装
    public static ByteBuf copiedBuffer(byte[] array) {
        return array.length == 0?EMPTY_BUFFER:wrappedBuffer((byte[])array.clone());
    }

	// 默认是堆内分配
    public static ByteBuf wrappedBuffer(byte[] array) {
        return (ByteBuf)(array.length == 0?EMPTY_BUFFER:new UnpooledHeapByteBuf(ALLOC, array, array.length));
    }
	
    // 也提供了堆外分配的方法
    private static final ByteBufAllocator ALLOC;
	
    public static ByteBuf directBuffer(int initialCapacity) {
        return ALLOC.directBuffer(initialCapacity);
    }	
复制代码

相对底层的分配方法是使用ByteBufAllocator，Netty实现了PooledByteBufAllocator和UnpooledByteBufAllocator，前者使用了jemalloc（一种malloc()的实现）来分配内存，而且实现了对ByteBuf的池化以提升性能。后者分配的是未池化的ByteBuf，其分配方式与以前讲的一致。

Channel channel = ...;
	ByteBufAllocator allocator = channel.alloc();
	ByteBuf buffer = allocator.directBuffer();
	do something.......
复制代码

为了优化内存使用率，Netty提供了一套手动的方式来追踪不活跃对象，像UnpooledHeapByteBuf这种分配在堆内的对象得益于JVM的GC管理，无需额外操心，而UnpooledDirectByteBuf是在堆外分配的，它的内部基于DirectByteBuffer，DirectByteBuffer会先向Bits类申请一个额度（Bits还拥有一个全局变量totalCapacity，记录了全部DirectByteBuffer总大小），每次申请前都会查看是否已经超过-XX:MaxDirectMemorySize所设置的上限，若是超限就会尝试调用Sytem.gc()，以试图回收一部份内存，而后休眠100毫秒，若是内存仍是不足，则只能抛出OOM异常。堆外内存的回收虽然有了这么一层保障，但为了提升性能与使用率，主动回收也是颇有必要的。因为Netty还实现了ByteBuf的池化，像PooledHeapByteBuf和PooledDirectByteBuf就必须依赖于手动的方式来进行回收（放回池中）。

Netty使用了引用计数器的方式来追踪那些不活跃的对象。引用计数的接口为ReferenceCounted，它的思想很简单，只要ByteBuf对象的引用计数大于0，就保证该对象不会被释放回收，能够经过手动调用release()与retain()方法来操做该对象的引用计数值递减或递增。用户也能够经过自定义一个ReferenceCounted的实现类，以知足自定义的规则。

package io.netty.buffer;
public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
	// 因为ByteBuf的实例对象会很是多,因此这里没有将refCnt包装为AtomicInteger
	// 而是使用一个全局的AtomicIntegerFieldUpdater来负责操做refCnt
    private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
	// 每一个ByteBuf的初始引用值都为1
    private volatile int refCnt = 1;

    public int refCnt() {
        return this.refCnt;
    }

    protected final void setRefCnt(int refCnt) {
        this.refCnt = refCnt;
    }
	
    public ByteBuf retain() {
        return this.retain0(1);
    }	
	
	// 引用计数值递增increment，increment必须大于0
    public ByteBuf retain(int increment) {
        return this.retain0(ObjectUtil.checkPositive(increment, "increment"));
    }
	
    public static int checkPositive(int i, String name) {
        if(i <= 0) {
            throw new IllegalArgumentException(name + ": " + i + " (expected: > 0)");
        } else {
            return i;
        }
    }
	
	// 使用CAS操做不断尝试更新值
    private ByteBuf retain0(int increment) {
        int refCnt;
        int nextCnt;
        do {
            refCnt = this.refCnt;
            nextCnt = refCnt + increment;
            if(nextCnt <= increment) {
                throw new IllegalReferenceCountException(refCnt, increment);
            }
        } while(!refCntUpdater.compareAndSet(this, refCnt, nextCnt));

        return this;
    }
	
    public boolean release() {
        return this.release0(1);
    }

    public boolean release(int decrement) {
        return this.release0(ObjectUtil.checkPositive(decrement, "decrement"));
    }
	
    private boolean release0(int decrement) {
        int refCnt;
        do {
            refCnt = this.refCnt;
            if(refCnt < decrement) {
                throw new IllegalReferenceCountException(refCnt, -decrement);
            }
        } while(!refCntUpdater.compareAndSet(this, refCnt, refCnt - decrement));

        if(refCnt == decrement) {
            this.deallocate(); 
            return true;
        } else {
            return false;
        }
    }
	
    protected abstract void deallocate();	
}
复制代码

Channel

Netty中的Channel与Java NIO的概念同样，都是对一个实体或链接的抽象，但Netty提供了一套更加通用的API。就以网络套接字为例，在Java中OIO与NIO是大相径庭的两套API，假设你以前使用的是OIO而又想更改成NIO实现，那么几乎须要重写全部代码。而在Netty中，只须要更改短短几行代码（更改Channel与EventLoop的实现类，如把OioServerSocketChannel替换为NioServerSocketChannel），就能够完成OIO与NIO（或其余）之间的转换。

每一个Channel最终都会被分配一个ChannelPipeline和ChannelConfig，前者持有全部负责处理入站与出站数据以及事件的ChannelHandler，后者包含了该Channel的全部配置设置，而且支持热更新，因为不一样的传输类型可能具备其特别的配置，因此该类可能会实现为ChannelConfig的不一样子类。

Channel是线程安全的（与以后要讲的线程模型有关），所以你彻底能够在多个线程中复用同一个Channel，就像以下代码所示。

final Channel channel = ...
final ByteBuf buffer = Unpooled.copiedBuffer("Hello,World!", CharsetUtil.UTF_8).retain();
Runnable writer = new Runnable() {
	@Override
	public void run() {
		channel.writeAndFlush(buffer.duplicate());
	}
};

Executor executor = Executors.newCachedThreadPool();
executor.execute(writer);
executor.execute(writer);
.......
复制代码

Netty除了支持常见的NIO与OIO，还内置了其余的传输类型。

Nmae	Package	Description
NIO	io.netty.channel.socket.nio	以Java NIO为基础实现
OIO	io.netty.channel.socket.oio	以java.net为基础实现，使用阻塞I/O模型
Epoll	io.netty.channel.epoll	由JNI驱动epoll()实现的更高性能的非阻塞I/O，它只能使用在Linux
Local	io.netty.channel.local	本地传输，在JVM内部经过管道进行通讯
Embedded	io.netty.channel.embedded	容许在不须要真实网络传输的环境下使用ChannelHandler，主要用于对ChannelHandler进行测试

NIO、OIO、Epoll咱们应该已经很熟悉了，下面主要说说Local与Embedded。

Local传输用于在同一个JVM中运行的客户端和服务器程序之间的异步通讯，与服务器Channel相关联的SocketAddress并无绑定真正的物理网络地址，它会被存储在注册表中，并在Channel关闭时注销。所以Local传输不会接受真正的网络流量，也就是说它不能与其余传输实现进行互操做。

Embedded传输主要用于对ChannelHandler进行单元测试，ChannelHandler是用于处理消息的逻辑组件，Netty经过将入站消息与出站消息都写入到EmbeddedChannel中的方式（提供了write/readInbound()与write/readOutbound()来读写入站与出站消息）来实现对ChannelHandler的单元测试。

ChannelHandler

ChannelHandler充当了处理入站和出站数据的应用程序逻辑的容器，该类是基于事件驱动的，它会响应相关的事件而后去调用其关联的回调函数，例如当一个新的链接被创建时，ChannelHandler的channelActive()方法将会被调用。

关于入站消息和出站消息的数据流向定义，若是以客户端为主视角来讲的话，那么从客户端流向服务器的数据被称为出站，反之为入站。

入站事件是可能被入站数据或者相关的状态更改而触发的事件，包括：链接已被激活、链接失活、读取入站数据、用户事件、发生异常等。

出站事件是将来将会触发的某个动做的结果的事件，这些动做包括：打开或关闭远程节点的链接、将数据写（或冲刷）到套接字。

ChannelHandler的主要用途包括：

对入站与出站数据的业务逻辑处理
记录日志
将数据从一种格式转换为另外一种格式，实现编解码器。以一次HTTP协议（或者其余应用层协议）的流程为例，数据在网络传输时的单位为字节，当客户端发送请求到服务器时，服务器须要经过解码器（处理入站消息）将字节解码为协议的消息内容，服务器在发送响应的时候（处理出站消息），还须要经过编码器将消息内容编码为字节。
捕获异常
提供Channel生命周期内的通知，如Channel活动时与非活动时

Netty中处处都充满了异步与事件驱动，而回调函数正是用于响应事件以后的操做。因为异步会直接返回一个结果，因此Netty提供了ChannelFuture（实现了java.util.concurrent.Future）来做为异步调用返回的占位符，真正的结果会在将来的某个时刻完成，到时候就能够经过ChannelFuture对其进行访问，每一个Netty的出站I/O操做都将会返回一个ChannelFuture。

Netty还提供了ChannelFutureListener接口来监听ChannelFuture是否成功，并采起对应的操做。

Channel channel = ...
ChannelFuture future = channel.connect(new InetSocketAddress("192.168.0.1",6666));
// 注册一个监听器
future.addListener(new ChannelFutureListener() {
	@Override
	public void operationComplete(ChannelFuture future) {
		if (future.isSuccess()) {
			// do something....
		} else {
			// 输出错误信息
			Throwable cause = future.cause();
			cause.printStackTrace();
			// do something....
		}
	}
});
复制代码

ChannelFutureListener接口中还提供了几个简单的默认实现，方便咱们使用。

package io.netty.channel;

import io.netty.channel.ChannelFuture;
import io.netty.util.concurrent.GenericFutureListener;

public interface ChannelFutureListener extends GenericFutureListener<ChannelFuture> {
	// 在Future完成时关闭
    ChannelFutureListener CLOSE = new ChannelFutureListener() {
        public void operationComplete(ChannelFuture future) {
            future.channel().close();
        }
    };
	// 若是失败则关闭
    ChannelFutureListener CLOSE_ON_FAILURE = new ChannelFutureListener() {
        public void operationComplete(ChannelFuture future) {
            if(!future.isSuccess()) {
                future.channel().close();
            }

        }
    };
	// 将异常信息传递给下一个ChannelHandler
    ChannelFutureListener FIRE_EXCEPTION_ON_FAILURE = new ChannelFutureListener() {
        public void operationComplete(ChannelFuture future) {
            if(!future.isSuccess()) {
                future.channel().pipeline().fireExceptionCaught(future.cause());
            }

        }
    };
}
复制代码

ChannelHandler接口定义了对它生命周期进行监听的回调函数，在ChannelHandler被添加到ChannelPipeline或者被移除时都会调用这些函数。

package io.netty.channel;

public interface ChannelHandler {
    void handlerAdded(ChannelHandlerContext var1) throws Exception;

    void handlerRemoved(ChannelHandlerContext var1) throws Exception;

    /** @deprecated */
    @Deprecated
    void exceptionCaught(ChannelHandlerContext var1, Throwable var2) throws Exception;
	
	// 该注解代表这个ChannelHandler可被其余线程复用
    @Inherited
    @Documented
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Sharable {
    }
}
复制代码

入站消息与出站消息由其对应的接口ChannelInboundHandler与ChannelOutboundHandler负责，这两个接口定义了监听Channel的生命周期的状态改变事件的回调函数。

package io.netty.channel;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;

public interface ChannelInboundHandler extends ChannelHandler {
	// 当channel被注册到EventLoop时被调用
    void channelRegistered(ChannelHandlerContext var1) throws Exception;
	
	// 当channel已经被建立，但还未注册到EventLoop（或者从EventLoop中注销）被调用
    void channelUnregistered(ChannelHandlerContext var1) throws Exception;
	
	// 当channel处于活动状态（链接到远程节点）被调用
    void channelActive(ChannelHandlerContext var1) throws Exception;

	// 当channel处于非活动状态（没有链接到远程节点）被调用
    void channelInactive(ChannelHandlerContext var1) throws Exception;
	
	// 当从channel读取数据时被调用
    void channelRead(ChannelHandlerContext var1, Object var2) throws Exception;
	
	// 当channel的上一个读操做完成时被调用
    void channelReadComplete(ChannelHandlerContext var1) throws Exception;
	
	// 当ChannelInboundHandler.fireUserEventTriggered()方法被调用时被调用
    void userEventTriggered(ChannelHandlerContext var1, Object var2) throws Exception;
	
	// 当channel的可写状态发生改变时被调用
    void channelWritabilityChanged(ChannelHandlerContext var1) throws Exception;
	
	// 当处理过程当中发生异常时被调用
    void exceptionCaught(ChannelHandlerContext var1, Throwable var2) throws Exception;
}

package io.netty.channel;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import java.net.SocketAddress;

public interface ChannelOutboundHandler extends ChannelHandler {

	// 当请求将Channel绑定到一个地址时被调用
	// ChannelPromise是ChannelFuture的一个子接口，定义了如setSuccess(),setFailure()等方法
    void bind(ChannelHandlerContext var1, SocketAddress var2, ChannelPromise var3) throws Exception;
	
	// 当请求将Channel链接到远程节点时被调用
    void connect(ChannelHandlerContext var1, SocketAddress var2, SocketAddress var3, ChannelPromise var4) throws Exception;
	
	// 当请求将Channel从远程节点断开时被调用
    void disconnect(ChannelHandlerContext var1, ChannelPromise var2) throws Exception;

	// 当请求关闭Channel时被调用
    void close(ChannelHandlerContext var1, ChannelPromise var2) throws Exception;

	// 当请求将Channel从它的EventLoop中注销时被调用
    void deregister(ChannelHandlerContext var1, ChannelPromise var2) throws Exception;
	
	// 当请求从Channel读取数据时被调用
    void read(ChannelHandlerContext var1) throws Exception;

	// 当请求经过Channel将数据写到远程节点时被调用
    void write(ChannelHandlerContext var1, Object var2, ChannelPromise var3) throws Exception;
	
	// 当请求经过Channel将缓冲中的数据冲刷到远程节点时被调用
    void flush(ChannelHandlerContext var1) throws Exception;
}
复制代码

经过实现ChannelInboundHandler或者ChannelOutboundHandler就能够完成用户自定义的应用逻辑处理程序，不过Netty已经帮你实现了一些基本操做，用户只须要继承并扩展ChannelInboundHandlerAdapter或ChannelOutboundHandlerAdapter来做为自定义实现的起始点。

ChannelInboundHandlerAdapter与ChannelOutboundHandlerAdapter都继承于ChannelHandlerAdapter，该抽象类简单实现了ChannelHandler接口。

public abstract class ChannelHandlerAdapter implements ChannelHandler {
    boolean added;

    public ChannelHandlerAdapter() {
    }
	
	// 该方法不容许将此ChannelHandler共享复用
    protected void ensureNotSharable() {
        if(this.isSharable()) {
            throw new IllegalStateException("ChannelHandler " + this.getClass().getName() + " is not allowed to be shared");
        }
    }
	
	// 使用反射判断实现类有没有@Sharable注解，以确认该类是否为可共享复用的
    public boolean isSharable() {
        Class clazz = this.getClass();
        Map cache = InternalThreadLocalMap.get().handlerSharableCache();
        Boolean sharable = (Boolean)cache.get(clazz);
        if(sharable == null) {
            sharable = Boolean.valueOf(clazz.isAnnotationPresent(Sharable.class));
            cache.put(clazz, sharable);
        }

        return sharable.booleanValue();
    }

    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    }

    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
    }

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.fireExceptionCaught(cause);
    }
}
复制代码

ChannelInboundHandlerAdapter与ChannelOutboundHandlerAdapter默认只是简单地将请求传递给ChannelPipeline中的下一个ChannelHandler，源码以下：

public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {
    public ChannelInboundHandlerAdapter() {
    }

    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelRegistered();
    }

    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelUnregistered();
    }

    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelActive();
    }

    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelInactive();
    }

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ctx.fireChannelRead(msg);
    }

    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelReadComplete();
    }

    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        ctx.fireUserEventTriggered(evt);
    }

    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelWritabilityChanged();
    }

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.fireExceptionCaught(cause);
    }
}

public class ChannelOutboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelOutboundHandler {
    public ChannelOutboundHandlerAdapter() {
    }

    public void bind(ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) throws Exception {
        ctx.bind(localAddress, promise);
    }

    public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) throws Exception {
        ctx.connect(remoteAddress, localAddress, promise);
    }

    public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        ctx.disconnect(promise);
    }

    public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        ctx.close(promise);
    }

    public void deregister(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        ctx.deregister(promise);
    }

    public void read(ChannelHandlerContext ctx) throws Exception {
        ctx.read();
    }

    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        ctx.write(msg, promise);
    }

    public void flush(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }
}
复制代码

对于处理入站消息，另一种选择是继承SimpleChannelInboundHandler，它是Netty的一个继承于ChannelInboundHandlerAdapter的抽象类，并在其之上实现了自动释放资源的功能。

咱们在了解ByteBuf时就已经知道了Netty使用了一套本身实现的引用计数算法来主动释放资源，假设你的ChannelHandler继承于ChannelInboundHandlerAdapter或ChannelOutboundHandlerAdapter，那么你就有责任去管理你所分配的ByteBuf，通常来讲，一个消息对象（ByteBuf）已经被消费（或丢弃）了，而且不会传递给ChannelHandler链中的下一个处理器（若是该消息到达了实际的传输层，那么当它被写入或Channel关闭时，都会被自动释放），那么你就须要去手动释放它。经过一个简单的工具类ReferenceCountUtil的release方法，就能够作到这一点。

// 这个泛型为消息对象的类型
public abstract class SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter {
    private final TypeParameterMatcher matcher;
    private final boolean autoRelease;

    protected SimpleChannelInboundHandler() {
        this(true);
    }

    protected SimpleChannelInboundHandler(boolean autoRelease) {
        this.matcher = TypeParameterMatcher.find(this, SimpleChannelInboundHandler.class, "I");
        this.autoRelease = autoRelease;
    }

    protected SimpleChannelInboundHandler(Class<? extends I> inboundMessageType) {
        this(inboundMessageType, true);
    }

    protected SimpleChannelInboundHandler(Class<? extends I> inboundMessageType, boolean autoRelease) {
        this.matcher = TypeParameterMatcher.get(inboundMessageType);
        this.autoRelease = autoRelease;
    }

    public boolean acceptInboundMessage(Object msg) throws Exception {
        return this.matcher.match(msg);
    }
	
	// SimpleChannelInboundHandler只是替你作了ReferenceCountUtil.release()
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        boolean release = true;

        try {
            if(this.acceptInboundMessage(msg)) {
                this.channelRead0(ctx, msg);
            } else {
                release = false;
                ctx.fireChannelRead(msg);
            }
        } finally {
            if(this.autoRelease && release) {
                ReferenceCountUtil.release(msg);
            }

        }

    }
	// 这个方法才是咱们须要实现的方法
    protected abstract void channelRead0(ChannelHandlerContext var1, I var2) throws Exception;
}
	
	// ReferenceCountUtil中的源码，release方法对消息对象的类型进行判断而后调用它的release()方法
    public static boolean release(Object msg) {
        return msg instanceof ReferenceCounted?((ReferenceCounted)msg).release():false;
    }
复制代码

ChannelPipeline

为了模块化与解耦合，不可能由一个ChannelHandler来完成全部应用逻辑，因此Netty采用了拦截器链的设计。ChannelPipeline就是用来管理ChannelHandler实例链的容器，它的职责就是保证明例链的流动。

每个新建立的Channel都将会被分配一个新的ChannelPipeline，这种关联关系是永久性的，一个Channel一辈子只能对应一个ChannelPipeline。

一个入站事件被触发时，它会先从ChannelPipeline的最左端（头部）开始一直传播到ChannelPipeline的最右端（尾部），而出站事件正好与入站事件顺序相反（从最右端一直传播到最左端）。这个顺序是定死的，Netty老是将ChannelPipeline的入站口做为头部，而将出站口做为尾部。在事件传播的过程当中，ChannelPipeline会判断下一个ChannelHandler的类型是否和事件的运动方向相匹配，若是不匹配，就跳过该ChannelHandler并继续检查下一个（保证入站事件只会被ChannelInboundHandler处理），一个ChannelHandler也能够同时实现ChannelInboundHandler与ChannelOutboundHandler，它在入站事件与出站事件中都会被调用。

在阅读ChannelHandler的源码时，发现不少方法须要一个ChannelHandlerContext类型的参数，该接口是ChannelPipeline与ChannelHandler之间相关联的关键。ChannelHandlerContext能够通知ChannelPipeline中的当前ChannelHandler的下一个ChannelHandler，还能够动态地改变当前ChannelHandler在ChannelPipeline中的位置（经过调用ChannelPipeline中的各类方法来修改）。

ChannelHandlerContext负责了在同一个ChannelPipeline中的ChannelHandler与其余ChannelHandler之间的交互，每一个ChannelHandlerContext都对应了一个ChannelHandler。在DefaultChannelPipeline的源码中，已经表现的很明显了。

public class DefaultChannelPipeline implements ChannelPipeline {
    .........
	// 头部节点和尾部节点的引用变量
	// ChannelHandlerContext在ChannelPipeline中是以链表的形式组织的
    final AbstractChannelHandlerContext head; 
    final AbstractChannelHandlerContext tail;	
	.........
	
	// 添加一个ChannelHandler到链表尾部
    public final ChannelPipeline addLast(String name, ChannelHandler handler) {
        return this.addLast((EventExecutorGroup)null, name, handler);
    }

    public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
        final AbstractChannelHandlerContext newCtx;
        synchronized(this) {
			// 检查ChannelHandler是否为一个共享对象(@Sharable)
			// 若是该ChannelHandler没有@Sharable注解，而且是已被添加过的那么就抛出异常
            checkMultiplicity(handler); 
			// 返回一个DefaultChannelHandlerContext，注意该对象持有了传入的ChannelHandler
            newCtx = this.newContext(group, this.filterName(name, handler), handler);
            this.addLast0(newCtx);
			// 若是当前ChannelPipeline没有被注册，那么就先加到未决链表中
            if(!this.registered) {
                newCtx.setAddPending();
                this.callHandlerCallbackLater(newCtx, true);
                return this;
            }
			
			// 不然就调用ChannelHandler中的handlerAdded()
            EventExecutor executor = newCtx.executor();
            if(!executor.inEventLoop()) {
                newCtx.setAddPending();
                executor.execute(new Runnable() {
                    public void run() {
                        DefaultChannelPipeline.this.callHandlerAdded0(newCtx);
                    }
                });
                return this;
            }
        }

        this.callHandlerAdded0(newCtx);
        return this;
    }
	
	// 将新的ChannelHandlerContext插入到尾部与尾部以前的节点之间
    private void addLast0(AbstractChannelHandlerContext newCtx) {
        AbstractChannelHandlerContext prev = this.tail.prev;
        newCtx.prev = prev;
        newCtx.next = this.tail;
        prev.next = newCtx;
        this.tail.prev = newCtx;
    }
	.....
}
复制代码

ChannelHandlerContext还定义了许多与Channel和ChannelPipeline重合的方法（像read()、write()、connect()这些用于出站的方法或者如fireChannelXXXX()这样用于入站的方法），不一样之处在于调用Channel或者ChannelPipeline上的这些方法，它们将会从头沿着整个ChannelHandler实例链进行传播，而调用位于ChannelHandlerContext上的相同方法，则会从当前所关联的ChannelHandler开始，且只会传播给实例链中的下一个ChannelHandler。并且，事件之间的移动（从一个ChannelHandler到下一个ChannelHandler）也是经过ChannelHandlerContext中的方法调用完成的。

public class DefaultChannelPipeline implements ChannelPipeline {	

    public final ChannelPipeline fireChannelRead(Object msg) {
		// 注意这里将头节点传入了进去
        AbstractChannelHandlerContext.invokeChannelRead(this.head, msg);
        return this;
    }
	
}

abstract class AbstractChannelHandlerContext extends DefaultAttributeMap implements ChannelHandlerContext, ResourceLeakHint {

    static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
        final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
        EventExecutor executor = next.executor();
        if(executor.inEventLoop()) {
            next.invokeChannelRead(m);
        } else {
            executor.execute(new Runnable() {
                public void run() {
                    next.invokeChannelRead(m);
                }
            });
        }

    }
	
    private void invokeChannelRead(Object msg) {
        if(this.invokeHandler()) {
            try {
                ((ChannelInboundHandler)this.handler()).channelRead(this, msg);
            } catch (Throwable var3) {
                this.notifyHandlerException(var3);
            }
        } else {
			// 寻找下一个ChannelHandler
            this.fireChannelRead(msg);
        }

    }	

    public ChannelHandlerContext fireChannelRead(Object msg) {
        invokeChannelRead(this.findContextInbound(), msg);
        return this;
    }

    private AbstractChannelHandlerContext findContextInbound() {
        AbstractChannelHandlerContext ctx = this;

        do {
            ctx = ctx.next;
        } while(!ctx.inbound); // 直到找到一个ChannelInboundHandler

        return ctx;
    }
	
}
复制代码

EventLoop

为了最大限度地提供高性能和可维护性，Netty设计了一套强大又易用的线程模型。在一个网络框架中，最重要的能力是可以快速高效地处理在链接的生命周期内发生的各类事件，与之相匹配的程序构造被称为事件循环，Netty定义了接口EventLoop来负责这项工做。

若是是常常用Java进行多线程开发的童鞋想必常常会使用到线程池，也就是Executor这套API。Netty就是从Executor（java.util.concurrent）之上扩展了本身的EventExecutorGroup（io.netty.util.concurrent），同时为了与Channel的事件进行交互，还扩展了EventLoopGroup接口（io.netty.channel）。在io.netty.util.concurrent包下的EventExecutorXXX负责实现线程并发相关的工做，而在io.netty.channel包下的EventLoopXXX负责实现网络编程相关的工做（处理Channel中的事件）。

在Netty的线程模型中，一个EventLoop将由一个永远不会改变的Thread驱动，而一个Channel一辈子只会使用一个EventLoop（可是一个EventLoop可能会被指派用于服务多个Channel），在Channel中的全部I/O操做和事件都由EventLoop中的线程处理，也就是说一个Channel的一辈子之中都只会使用到一个线程。不过在Netty3，只有入站事件会被EventLoop处理，全部出站事件都会由调用线程处理，这种设计致使了ChannelHandler的线程安全问题。Netty4简化了线程模型，经过在同一个线程处理全部事件，既解决了这个问题，还提供了一个更加简单的架构。

package io.netty.channel;

public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop {
    protected static final int DEFAULT_MAX_PENDING_TASKS = Math.max(16, SystemPropertyUtil.getInt("io.netty.eventLoop.maxPendingTasks", 2147483647));
    private final Queue<Runnable> tailTasks;

    protected SingleThreadEventLoop(EventLoopGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp) {
        this(parent, threadFactory, addTaskWakesUp, DEFAULT_MAX_PENDING_TASKS, RejectedExecutionHandlers.reject());
    }

    protected SingleThreadEventLoop(EventLoopGroup parent, Executor executor, boolean addTaskWakesUp) {
        this(parent, executor, addTaskWakesUp, DEFAULT_MAX_PENDING_TASKS, RejectedExecutionHandlers.reject());
    }

    protected SingleThreadEventLoop(EventLoopGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedExecutionHandler) {
        super(parent, threadFactory, addTaskWakesUp, maxPendingTasks, rejectedExecutionHandler);
        this.tailTasks = this.newTaskQueue(maxPendingTasks);
    }

    protected SingleThreadEventLoop(EventLoopGroup parent, Executor executor, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedExecutionHandler) {
        super(parent, executor, addTaskWakesUp, maxPendingTasks, rejectedExecutionHandler);
        this.tailTasks = this.newTaskQueue(maxPendingTasks);
    }
	
	// 返回它所在的EventLoopGroup
    public EventLoopGroup parent() {
        return (EventLoopGroup)super.parent();
    }
	
    public EventLoop next() {
        return (EventLoop)super.next();
    }
	
	// 注册Channel,这里ChannelPromise和Channel关联到了一块儿
    public ChannelFuture register(Channel channel) {
        return this.register((ChannelPromise)(new DefaultChannelPromise(channel, this)));
    }

    public ChannelFuture register(ChannelPromise promise) {
        ObjectUtil.checkNotNull(promise, "promise");
        promise.channel().unsafe().register(this, promise);
        return promise;
    }
	
	// 剩下这些函数都是用于调度任务
    public final void executeAfterEventLoopIteration(Runnable task) {
        ObjectUtil.checkNotNull(task, "task");
        if(this.isShutdown()) {
            reject();
        }

        if(!this.tailTasks.offer(task)) {
            this.reject(task);
        }

        if(this.wakesUpForTask(task)) {
            this.wakeup(this.inEventLoop());
        }

    }

    final boolean removeAfterEventLoopIterationTask(Runnable task) {
        return this.tailTasks.remove(ObjectUtil.checkNotNull(task, "task"));
    }

    protected boolean wakesUpForTask(Runnable task) {
        return !(task instanceof SingleThreadEventLoop.NonWakeupRunnable);
    }

    protected void afterRunningAllTasks() {
        this.runAllTasksFrom(this.tailTasks);
    }

    protected boolean hasTasks() {
        return super.hasTasks() || !this.tailTasks.isEmpty();
    }

    public int pendingTasks() {
        return super.pendingTasks() + this.tailTasks.size();
    }

    interface NonWakeupRunnable extends Runnable {
    }
}
复制代码

为了确保一个Channel的整个生命周期中的I/O事件会被一个EventLoop负责，Netty经过inEventLoop()方法来判断当前执行的线程的身份，肯定它是不是分配给当前Channel以及它的EventLoop的那一个线程。若是当前（调用）线程正是EventLoop中的线程，那么所提交的任务将会被直接执行，不然，EventLoop将调度该任务以便稍后执行，并将它放入内部的任务队列（每一个EventLoop都有它本身的任务队列，从SingleThreadEventLoop的源码就能发现不少用于调度内部任务队列的方法），在下次处理它的事件时，将会执行队列中的那些任务。这种设计可让任何线程与Channel直接交互，而无需在ChannelHandler中进行额外的同步。

从性能上来考虑，千万不要将一个须要长时间来运行的任务放入到任务队列中，它会影响到该队列中的其余任务的执行。解决方案是使用一个专门的EventExecutor来执行它（ChannelPipeline提供了带有EventExecutorGroup参数的addXXX()方法，该方法能够将传入的ChannelHandler绑定到你传入的EventExecutor之中），这样它就会在另外一条线程中执行，与其余任务隔离。

public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
.....

    public void execute(Runnable task) {
        if(task == null) {
            throw new NullPointerException("task");
        } else {
            boolean inEventLoop = this.inEventLoop();
            if(inEventLoop) {
                this.addTask(task);
            } else {
                this.startThread();
                this.addTask(task);
                if(this.isShutdown() && this.removeTask(task)) {
                    reject();
                }
            }

            if(!this.addTaskWakesUp && this.wakesUpForTask(task)) {
                this.wakeup(inEventLoop);
            }

        }
    }
	
    public boolean inEventLoop(Thread thread) {
        return thread == this.thread;
    }
	
.....
}
复制代码

EventLoopGroup负责管理和分配EventLoop（建立EventLoop和为每一个新建立的Channel分配EventLoop），根据不一样的传输类型，EventLoop的建立和分配方式也不一样。例如，使用NIO传输类型，EventLoopGroup就会只使用较少的EventLoop（一个EventLoop服务于多个Channel），这是由于NIO基于I/O多路复用，一个线程能够处理多个链接，而若是使用的是OIO，那么新建立一个Channel（链接）就须要分配一个EventLoop（线程）。

Bootstrap

在深刻了解地Netty的核心组件以后，发现它们的设计都很模块化，若是想要实现你本身的应用程序，就须要将这些组件组装到一块儿。Netty经过Bootstrap类，以对一个Netty应用程序进行配置（组装各个组件），并最终使它运行起来。对于客户端程序和服务器程序所使用到的Bootstrap类是不一样的，后者须要使用ServerBootstrap，这样设计是由于，在如TCP这样有链接的协议中，服务器程序每每须要一个以上的Channel，经过父Channel来接受来自客户端的链接，而后建立子Channel用于它们之间的通讯，而像UDP这样无链接的协议，它不须要每一个链接都建立子Channel，只须要一个Channel便可。

一个比较明显的差别就是Bootstrap与ServerBootstrap的group()方法，后者提供了一个接收2个EventLoopGroup的版本。

// 该方法在Bootstrap的父类AbstractBootstrap中，泛型B为它当前子类的类型（为了链式调用）
    public B group(EventLoopGroup group) {
        if(group == null) {
            throw new NullPointerException("group");
        } else if(this.group != null) {
            throw new IllegalStateException("group set already");
        } else {
            this.group = group;
            return this;
        }
    }
	
	// ServerBootstrap中的实现，它也支持只用一个EventLoopGroup
    public ServerBootstrap group(EventLoopGroup group) {
        return this.group(group, group);
    }

    public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
        super.group(parentGroup);
        if(childGroup == null) {
            throw new NullPointerException("childGroup");
        } else if(this.childGroup != null) {
            throw new IllegalStateException("childGroup set already");
        } else {
            this.childGroup = childGroup;
            return this;
        }
    }	
复制代码

Bootstrap其实没有什么能够好说的，它就只是一个装配工，将各个组件拼装组合到一块儿，而后进行一些配置，有关它的详细API请参考Netty JavaDoc。下面咱们将经过一个经典的Echo客户端与服务器的例子，来梳理一遍建立Netty应用的流程。

首先实现的是服务器，咱们先实现一个EchoServerInboundHandler，处理入站消息。

public class EchoServerInboundHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.printf("Server received: %s \n", in.toString(CharsetUtil.UTF_8));
		// 因为读事件不是一次性就能把完整消息发送过来的，这里并无调用writeAndFlush
        ctx.write(in); // 直接把消息写回给客户端(会被出站消息处理器处理,不过咱们的应用没有实现任何出站消息处理器)
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // 等读事件已经完成时,冲刷以前写数据的缓冲区
		// 而后添加了一个监听器，它会在Future完成时进行关闭该Channel.
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)
                .addListener(ChannelFutureListener.CLOSE);
    }
	
	// 处理异常，输出异常信息，而后关闭Channel
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}
复制代码

服务器的应用逻辑只有这么多，剩下就是用ServerBootstrap进行配置了。

public class EchoServer {

    private final int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        final EchoServerInboundHandler serverHandler = new EchoServerInboundHandler();
        EventLoopGroup group = new NioEventLoopGroup(); // 传输类型使用NIO
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(group) // 配置EventLoopGroup
                    .channel(NioServerSocketChannel.class) // 配置Channel的类型
                    .localAddress(new InetSocketAddress(port)) // 配置端口号
                    .childHandler(new ChannelInitializer<SocketChannel>() { 
						// 实现一个ChannelInitializer，它能够方便地添加多个ChannelHandler
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(serverHandler);
                        }
                    });
            // i绑定地址，同步等待它完成
            ChannelFuture f = b.bind().sync();
            // 关闭这个Future
            f.channel().closeFuture().sync();
        } finally {
			// 关闭应用程序，通常来讲Netty应用只须要调用这个方法就够了
            group.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.printf(
                    "Usage: %s <port> \n",
                    EchoServer.class.getSimpleName()
            );
            return;
        }
        int port = Integer.parseInt(args[0]);
        new EchoServer(port).start();
    }

}
复制代码

接下来实现客户端，一样须要先实现一个入站消息处理器。

public class EchoClientInboundHandler extends SimpleChannelInboundHandler<ByteBuf> {

    /** * 咱们在Channel链接到远程节点直接发送一条消息给服务器 */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello, Netty!", CharsetUtil.UTF_8));
    }

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
		// 输出从服务器Echo的消息
        System.out.printf("Client received: %s \n", byteBuf.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}
复制代码

而后配置客户端。

public class EchoClient {

    private final String host;
    private final int port;

    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .remoteAddress(new InetSocketAddress(host, port)) // 服务器的地址
                    .handler(new ChannelInitializer<SocketChannel>() { 
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new EchoClientInboundHandler());
                        }
                    });
            ChannelFuture f = b.connect().sync(); // 链接到服务器
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 2) {
            System.err.printf("Usage: %s <host> <port> \n", EchoClient.class.getSimpleName());
            return;
        }

        String host = args[0];
        int port = Integer.parseInt(args[1]);
        new EchoClient(host, port).start();
    }

}
复制代码

实现一个Netty应用程序就是如此简单，用户大多数都是在编写各类应用逻辑的ChannelHandler（或者使用Netty内置的各类实用ChannelHandler），而后只须要将它们所有添加到ChannelPipeline便可。