Netty4.x源码分析：Netty常见组件(Channe、Unsafe、Pipeline)
当我们看Netty源码分析的时候，经常会看到几个常见组件比如Channel、Pipeline、Unsafe、EventLoopGroup、EventLoop。每个组件都是必不可少，而且这种设计对网络通信和逻辑处理的解耦起到非常重要的作用，比如我们在应用层不用关系底层网络通信的实现逻辑，只需编写ChannelHandler针对不同的请求事件处理即可。当我们想把BIO切换到NIO只需要做小小的变动，即可完成切换。所以我们今天主要来分析下三个比较关键的组件Channel、Unsafe、Pipeline。它们的作用如下：
Channel：用于执行网络I/O操作【BIO、NIO等等】，它是一个顶层的接口，针对不同的I/O类型它有不同的实现类，下面做一个简单的展示
列举一些常见的Channel类型：
- NioSocketChannel：代表异步的客户端 TCP Socket 连接
- NioServerSocketChannel：异步的服务器端 TCP Socket 连接
- NioDatagramChannel：异步的 UDP 连接
- NioSctpChannel：异步的客户端 Sctp 连接
- NioSctpServerChannel：异步的 Sctp 服务器端连接
- OioSocketChannel：同步的客户端 TCP Socket 连接（也就是BIO）
- OioServerSocketChannel：同步的服务器端 TCP Socket 连接
- OioDatagramChannel：同步的 UDP 连接
- OioSctpChannel：同步的 Sctp 服务器端连接
- OioSctpServerChannel：同步的客户端 TCP Socket 连接
Unsafe：这个不是我们常说的Java自带的sun.misc.Unsafe；我觉得因为它是不能被用户代码调用，所以取名叫做Unsafe；它的作用主要是用于数据传输操作，比如发送消息、把Channel注册到EventLoop等等数据操作。Unsafe主要跟自己专属的Channel一起使用
下面是它相关的API，我们从中也可以简单的了解它的作用
interface Unsafe {
RecvByteBufAllocator.Handle recvBufAllocHandle();
SocketAddress localAddress();
SocketAddress remoteAddress();
void register(EventLoop eventLoop, ChannelPromise promise);
void bind(SocketAddress localAddress, ChannelPromise promise);
void connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise);
void disconnect(ChannelPromise promise);
void close(ChannelPromise promise);
void closeForcibly();
void deregister(ChannelPromise promise);
void beginRead();
void write(Object msg, ChannelPromise promise);
void flush();
ChannelPromise voidPromise();
ChannelOutboundBuffer outboundBuffer();
}
下面列举一下它的常用的实现类：
从上面我们很容易了解到，针对不同的I/O类型它都有一种不同的实现，下面对几个常见的Unsafe做一个介绍
- NioMessageUnsafe：主要处理NIO服务端的一些I/O操作
- NioSocketChannelUnsafe：主要处理NIO客户端的一些I/O操作
- DefaultOioUnsafe：主要处理传统BIO的一些I/O操作
Pipeline:Pipeline中由ChannelHandler组成的一条双向链表，创建一个Pipeline默认有一个头（HeadContext）、尾(TailContext)节点。ChannelHandler它是Channel中的逻辑处理，我们使用比较多的就是ChannelHandler这一块。
源码分析
我们从上面分析可知Unsafe、Pipeline都是跟Channel有关联的，那么我们就从Channel为出发点，而且从Channel的类图我们可以看到，AbstractChannel是最顶层的父类，那么我们就以AbstractChannel的源码开始分析。
AbstractChannel的API如下：
我们主要从构造器->bind()->connect()简单浏览下源码
Channel构造器
首先我们来看AbstractChannel的构造器，它有2个构造器，不过都大同小异，一个需要子类传入ChannelId，一个是调用newId()自动生成
protected AbstractChannel(Channel parent) {
this.parent = parent;
id = newId();
unsafe = newUnsafe();
pipeline = newChannelPipeline();
}
protected AbstractChannel(Channel parent, ChannelId id) {
this.parent = parent;
this.id = id;
unsafe = newUnsafe();
pipeline = newChannelPipeline();
}
这里主要由三个关键方法
- newId()：创建一个ChannelId
- newUnsafe()：构建Unsafe对象，这个需要调用子类的newUnsafe()方法生成实例，因为它不知道子类使用的是那种I/O类型
- newChannelPipeline()：创建一个Pipeline。双向链表组成
protected ChannelId newId() {
return DefaultChannelId.newInstance();
}
public static DefaultChannelId newInstance() {
return new DefaultChannelId();
}
private DefaultChannelId() {
data = new byte[MACHINE_ID.length + PROCESS_ID_LEN + SEQUENCE_LEN + TIMESTAMP_LEN + RANDOM_LEN];
int i = 0;
// machineId
System.arraycopy(MACHINE_ID, 0, data, i, MACHINE_ID.length);
i += MACHINE_ID.length;
// processId
i = writeInt(i, PROCESS_ID);
// sequence
i = writeInt(i, nextSequence.getAndIncrement());
// timestamp (kind of)
i = writeLong(i, Long.reverse(System.nanoTime()) ^ System.currentTimeMillis());
// random
int random = PlatformDependent.threadLocalRandom().nextInt();
i = writeInt(i, random);
assert i == data.length;
hashCode = Arrays.hashCode(data);
}
ChannelId主要由机器Id、进程Id、数字、时间戳、随机数组成
newUnsafe()它是一个模板方法，那么就以NIO的Server端的NioServceSocketChannel为例，那么调用的则是AbstractNioMessageChannel的newUnsafe()
protected AbstractNioUnsafe newUnsafe() {
return new NioMessageUnsafe();
}
这里很简单，就创建了一个NioMessageUnsafe实例
newChannelPipeline()方法也很简单，就是创建了一个DefaultChannelPipeline实例，并且把Channel实例传给了DefaultChannelPipeline对象。
protected DefaultChannelPipeline newChannelPipeline() {
return new DefaultChannelPipeline(this);
}
protected DefaultChannelPipeline(Channel channel) {
this.channel = ObjectUtil.checkNotNull(channel, "channel");
succeededFuture = new SucceededChannelFuture(channel, null);
voidPromise = new VoidChannelPromise(channel, true);
/**
* 创建了一个尾节点、头节点
*/
tail = new TailContext(this);
head = new HeadContext(this);
/**
* 尾节点和头节点互相关联，形成一个双向链表
*/
head.next = tail;
tail.prev = head;
}
我们来看一下 经常使用的DefaultChannelPipeline的addLast()方法
public final ChannelPipeline addLast(ChannelHandler handler) {
return addLast(null, handler);
}
@Override
public final ChannelPipeline addLast(String name, ChannelHandler handler) {
return addLast(null, name, handler);
}
@Override
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
final AbstractChannelHandlerContext newCtx;
synchronized (this) {
checkMultiplicity(handler);
/**
* 把ChannelHandler包装成一个AbstractChannelHandlerContext
*/
newCtx = newContext(group, filterName(name, handler), handler);
/**
* 把上面生成的Context加入链表中，即尾节点的前面
*/
addLast0(newCtx);
//下面省略一些其他代码，有兴趣的，可以去看下我前面讲的Netty4.x源码分析：服务端绑定端口有讲
return this;
}
private void addLast0(AbstractChannelHandlerContext newCtx) {
AbstractChannelHandlerContext prev = tail.prev;
newCtx.prev = prev;
newCtx.next = tail;
prev.next = newCtx;
tail.prev = newCtx;
}
AbstractChannel的构造方法，主要做了3件事情
- 通过newId()生成一个ChannelId
- 通过调用newUnsafe()模板方法，根据子类的不同，生成不一样的Unsafe实例。
- 调用newChannelPipeline()生成一个双向链表的Pipeline，默认有一个头结点（HeadContext）、尾节点(TailContext)；当我们调用addLast()，把ChannelHandler加到Pipeline，会把ChannelHandler包装成一个AbstractChannelHandlerContext节点，存到尾节点的前面。
这里我们也可以发现每个Channel都有对应的Unsafe实例、Pipeline实例。
Channel的bind()
我们还是以AbstractChannel的bind方法为入口
public ChannelFuture bind(SocketAddress localAddress) {
return pipeline.bind(localAddress);
}
这里调用了DefaultChannelPipeline的bind()
DefaultChannelPipeline
public final ChannelFuture bind(SocketAddress localAddress) {
return tail.bind(localAddress);
}
TailContext
public ChannelFuture bind(SocketAddress localAddress) {
return bind(localAddress, newPromise());
}
public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
if (localAddress == null) {
throw new NullPointerException("localAddress");
}
if (isNotValidPromise(promise, false)) {
// cancelled
return promise;
}
/**
* 从当前节点开始，找到Pipeline中前一个outbound节点
*/
final AbstractChannelHandlerContext next = findContextOutbound();
EventExecutor executor = next.executor();
/**
* 如果next节点是在当前线程执行的，那么直接同步执行next节点的bind方法
*/
if (executor.inEventLoop()) {
next.invokeBind(localAddress, promise);
} else {
/**
* 如果next节点指定了EventExecutor,那么就在指定的EventExecutor里异步调用next节点的bind方法
*/
safeExecute(executor, new Runnable() {
@Override
public void run() {
next.invokeBind(localAddress, promise);
}
}, promise, null);
}
return promise;
}
从上面我们知道，从尾节点TailContext开始往前找属于outbound的节点，然后调用该节点的bind方法。这时，我们先设想Pipeline中只有头结点HeadContext和尾节点TailContext，那么这时候就调用了HeadContext的bind方法。【这里解释一下HeadContext即是inbound又是outbound，可以去看下HeadContext的类结构就清楚了】
HeadContext
public void bind(
ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
throws Exception {
/**
* 这里就是调用了Unsafe的bind方法，上面我们说到，在创建Channel的时候，针对不同的I/O类型Channel都会创建一个特定的Unsafe实例。
* 那么我们还是以NIO为例，上面我们介绍过，创建NioServerSocketChannel的时候会创建NioMessageUnsafe实例。那么这里就是调用
* NioMessageUnsafe的bind方法，但是NioMessageUnsafe没有实现这个bind方法，所以就调用父类的AbstractUnsafe的bind方法
*/
unsafe.bind(localAddress, promise);
}
AbstractUnsafe
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
// 省略前面的
/**
* 我们只关注这个doBind方法，实现方法在Channel中。doBind它是一个模板方法，实现类在它的子类。
* 因为我们是NioServerSocketChannel，所以实现方法在NioServerSocketChannel类中，为什么要这样实现呢？其实很简单，
* 不同的I/O类型的绑定都是不一样的，而Channel是对应I/O操作相关的。所以自然而然真正的绑定端口肯定在对应的子类Channel中实
* 现
*/
doBind(localAddress);
// 省略后面的
}
NioServerSocketChannel
protected void doBind(SocketAddress localAddress) throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
javaChannel().bind(localAddress, config.getBacklog());
} else {
/**
* 这里就很简单了，调用了我们熟悉的JDK的API
*/
javaChannel().socket().bind(localAddress, config.getBacklog());
}
}
Channel的connect就不讲了，跟bind逻辑差不多，可以自己试着去分析下。
结论
1、Netty底层把I/O抽象成了Channel，对应不同I/O模型有对应的Channel实例与之对应。比如NIO的服务端就对应NioServerSocketChannel等等。这就当我们想改变I/O模型，只需要改变对应的Channel即可，非常之方便，并不需要关心底层的API。
2、创建Channel的时候会生成2个非常重要的组件Unsafe、Pipeline。Unsafe针对不同I/O模型也有对应的实现。而Pipeline不管使用哪种I/O模型都是一样的，都会创建一条DefaultChannelPipeline，它是一个双向链表，有一个头结点HeadContext、尾节点TailContext组成。
3、在Pipeline中执行业务逻辑的时候，是在单线程中执行的，所以是线程安全的。当我们在分析bind方法的时候，当取出下一个outbound的next节点时，首先判断它是否有指定的EventExecutor，如果没有，那么就同步执行，如果有，那么就异步在指定的EventExecutor内执行。这种设计减少了线程的上下文切换，并且是线程安全的，所以在Pipeline中不用考虑一些数据安全的问题，效率非常高。