本文详细分析了Netty如何注册和处理OP_ACCEPT、OP_READ、OP_WRITE事件。从创建ServerSocketChannel、设置非阻塞模式到注册SelectionKey，再到NioServerSocketChannel的doReadMessage处理连接请求，以及NioSocketChannel的OP_READ事件处理，揭示了Netty对Java NIO服务端封装的精妙之处。
抛开Netty，一个典型的Java NIO服务端开发需要做几件事:
1. 创建ServerSocketChannel,设置为非阻塞，并绑定端口
2. 创建Selector对象
3. 给ServerSocketChannel注册SelectionKey.OP_ACCEPT事件
4. 启动一个线程循环，调用Selector的select方法来检查IO就绪事件，一旦有IO就绪事件，就通知用户线程去处理IO事件
5. 如果有Accept事件，就创建一个SocketChannel，并注册SelectionKey_OP_READ
6. 如果有读事件，判断一下是否全包，如果全包，就交给后端线程处理
7. 写事件比较特殊。isWriteable表示的是本机的写缓冲区是否可写。这个在绝大多少情况下都是为真的。在Netty中只有写半包的时候才需要注册写事件，如果一次写就完全把数据写入了缓冲区就不需要注册写事件. 具体关于写事件的处理看这篇 http://blog.youkuaiyun.com/iter_zc/article/details/39291129
一个典型的Java NIO服务端的代码如下:
public NIOServer(int port) throws IOException {
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
ServerSocket serverSocket = serverSocketChannel.socket();
serverSocket.bind(port);
selector = Selector.open();
// 注册到selector，等待连接
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
}
private void eventloop() throws IOException {
while (true) {
selector.select();
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
iterator.remove();
handleSelectedKey(selectionKey);
}
}
} private void handleKey(SelectionKey selectionKey) throws IOException {
ServerSocketChannel server = null;
SocketChannel client = null;
if (selectionKey.isAcceptable()) {
server = (ServerSocketChannel) selectionKey.channel();
client = server.accept();
// 配置为非阻塞
client.configureBlocking(false);
// 注册到selector，等待连接
client.register(selector, SelectionKey.OP_READ);
} else if (selectionKey.isReadable()) {
client = (SocketChannel) selectionKey.channel();
client.read(receivebuffer);
} else if (selectionKey.isWritable()) {
sendbuffer.clear();
client = (SocketChannel) selectionKey.channel();
client.write(sendbuffer);
}
} 那么Netty是如何来注册Accept和读写事件的呢？ 首先来看如何注册的OP_ACCPET事件，是在服务器端绑定端口的过程中的，具体的绑定细节看这篇 http://blog.youkuaiyun.com/iter_zc/article/details/39349177 这里只分析注册OP_ACCEPT的过程。
在ServerBootstrap调用createChannel来创建NioServerSocketChannel的时候，会给NioServerSocketChannel传入要绑定的OP_ACCEPT事件，然后依次调用父类的构造函数，把readInterestOp往上传递，直到传递到AbstractNioChannel，作为AbstractNioChannel的一个实例属性readInterestOp.
public NioServerSocketChannel(EventLoop eventLoop, EventLoopGroup childGroup) {
super(null, eventLoop, childGroup, newSocket(), SelectionKey.OP_ACCEPT);
config = new DefaultServerSocketChannelConfig(this, javaChannel().socket());
}
protected AbstractNioMessageServerChannel(
Channel parent, EventLoop eventLoop, EventLoopGroup childGroup, SelectableChannel ch, int readInterestOp) {
super(parent, eventLoop, ch, readInterestOp);
this.childGroup = childGroup;
}
protected AbstractNioMessageChannel(
Channel parent, EventLoop eventLoop, SelectableChannel ch, int readInterestOp) {
super(parent, eventLoop, ch, readInterestOp);
}
protected AbstractNioChannel(Channel parent, EventLoop eventLoop, SelectableChannel ch, int readInterestOp) {
super(parent, eventLoop);
this.ch = ch;
this.readInterestOp = readInterestOp;
try {
ch.configureBlocking(false);
} catch (IOException e) {
try {
ch.close();
} catch (IOException e2) {
if (logger.isWarnEnabled()) {
logger.warn(
"Failed to close a partially initialized socket.", e2);
}
}
throw new ChannelException("Failed to enter non-blocking mode.", e);
}
}
可以看到在AbstractNioChannel的构造函数里面并没有把Channel注册到selector之上，只是把OP_ACCEPT赋值给了readInterestOp。在服务器绑定的过程中有一个register的过程，最后调用到了AbstractNioChannel的doRegister方法。这里可以看到调用的ServerSocketChannel得register方法，但是并没有注册具体的事件，传了一个0，表示不注册任何事件。这里做了一件事情就是把Channel作为Attachment绑定到了SelectionKey之上。
protected void doRegister() throws Exception {
boolean selected = false;
for (;;) {
try {
selectionKey = javaChannel().register(eventLoop().selector, 0, this);
return;
} catch (CancelledKeyException e) {
if (!selected) {
// Force the Selector to select now as the "canceled" SelectionKey may still be
// cached and not removed because no Select.select(..) operation was called yet.
eventLoop().selectNow();
selected = true;
} else {
// We forced a select operation on the selector before but the SelectionKey is still cached
// for whatever reason. JDK bug ?
throw e;
}
}
}
}
// SelectionKey的事件的值
public static final int OP_READ = 1 << 0; // 1
public static final int OP_WRITE = 1 << 2 // 4
public static final int OP_CONNECT = 1 << 3; // 8
public static final int OP_ACCEPT = 1 << 4; // 16
Channel注册到Selector有两种方式，一种是调用Channel的register方法，第二种是设置SelectionKey的interestOps的值。Netty是用了第二种方式，通过设置SelectionKey的interestOps来注册Channel关心的事件，把实际的注册延迟了。
在服务器端绑定的过程中，在bind完之后会fireChannelActive事件，在fireChannelActive执行之后，会让Channel主动发起一个outbound的读事件，通过Pipeline最后传递到HeadHandler，HeadHandler会实际使用Unsafe来进行读写。HeadHandler处理读时间时，调用了Unsafe的beginRead方法，最后到了AbstractNioChannel来设置SelectionKey的interestOps属性，来最终把Channel绑定到Selector。
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
if (!ensureOpen(promise)) {
return;
}
// See: https://github.com/netty/netty/issues/576
if (!PlatformDependent.isWindows() && !PlatformDependent.isRoot() &&
Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
localAddress instanceof InetSocketAddress &&
!((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress()) {
// Warn a user about the fact that a non-root user can't receive a
// broadcast packet on *nix if the socket is bound on non-wildcard address.
logger.warn(
"A non-root user can't receive a broadcast packet if the socket " +
"is not bound to 
最低0.47元/天 解锁文章
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
