分布式rpc框架有很多，比如dubbo,netty,还有很多其他的产品。但他们大部分都是基于nio的，
nio是非阻塞的io,那么它的内部机制是怎么实现的呢。
1.由一个专门的线程处理所有IO事件，并负责分发。
2.事件驱动机制，事件到来的时候触发操作，不需要阻塞的监视事件。
3.线程之前通过wait,notify通信，减少线程切换。
NIO使用步骤
步骤一：打开ServerSocketChannel，用于监听客户端的连接，它是所有客户端连接的父管道，代码示例如下：
ServerSocketChannel acceptorSvr = ServerSocketChannel.open();
步骤二：绑定监听端口，设置连接为非阻塞模式，示例代码如下：
acceptorSvr.socket().bind(new InetSocketAddress(InetAddress.getByName(“IP”), port)); acceptorSvr.configureBlocking(false);
步骤三：创建Reactor线程，创建多路复用器并启动线程，代码如下：
Selector selector = Selector.open(); New Thread(new ReactorTask()).start();
步骤四：将ServerSocketChannel注册到Reactor线程的多路复用器Selector上，监听ACCEPT事件，代码如下：
SelectionKey key = acceptorSvr.register( selector, SelectionKey.OP_ACCEPT, ioHandler);
步骤五：多路复用器在线程run方法的无限循环体内轮询准备就绪的Key，代码如下：
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {
SelectionKey key = (SelectionKey)it.next();
// ... deal with I/O event ...
}
步骤六：多路复用器监听到有新的客户端接入，处理新的接入请求，完成TCP三次握手，建立物理链路，代码示例如下：
SocketChannel channel = svrChannel.accept();
步骤七：设置客户端链路为非阻塞模式，示例代码如下：
channel.configureBlocking(false); channel.socket().setReuseAddress(true);
步骤八：将新接入的客户端连接注册到Reactor线程的多路复用器上，监听读操作，用来读取客户端发送的网络消息，代码如下：
SelectionKey key = socketChannel.register( selector, SelectionKey.OP_READ, ioHandler);
步骤九：异步读取客户端请求消息到缓冲区，示例代码如下：
int readNumber = channel.read(receivedBuffer);
步骤十：对ByteBuffer进行编解码，如果有半包消息指针reset，继续读取后续的报文，将解码成功的消息封装成Task，投递到业务线程池中，进行业务逻辑编排，示例代码如下：
Object message = null;
while(buffer.hasRemain())
{
byteBuffer.mark();
Object message = decode(byteBuffer);
if (message == null)
{
byteBuffer.reset();
break;
}
messageList.add(message );
}
if (!byteBuffer.hasRemain())
byteBuffer.clear();
else
byteBuffer.compact();
if (messageList != null & !messageList.isEmpty())
{
for(Object messageE : messageList)
handlerTask(messageE);
}
步骤十一：将POJO对象encode成ByteBuffer，调用SocketChannel的异步write接口，将消息异步发送给客户端，示例代码如下：
socketChannel.write(buffer);
注意：如果发送区TCP缓冲区满，会导致写半包，此时，需要注册监听写操作位，循环写，直到整包消息写入TCP缓冲区，此处不赘述，后续Netty源码分析章节会详细分析Netty的处理策略。
当我们了解创建NIO服务端的基本步骤之后，下面我们将前面的时间服务器程序通过NIO重写一遍，让大家能够学习到完整版的NIO服务端创建。
客户端步骤：
步骤一：打开SocketChannel，绑定客户端本地地址（可选，默认系统会随机分配一个可用的本地地址），示例代码如下：
SocketChannel clientChannel = SocketChannel.open();
步骤二：设置SocketChannel为非阻塞模式，同时设置客户端连接的TCP参数，示例代码如下：
clientChannel.configureBlocking(false);
socket.setReuseAddress(true);
socket.setReceiveBufferSize(BUFFER_SIZE);
socket.setSendBufferSize(BUFFER_SIZE);
步骤三：异步连接服务端，示例代码如下：
boolean connected = clientChannel.connect(new InetSocketAddress(“ip”,port));
步骤四：判断是否连接成功，如果连接成功，则直接注册读状态位到多路复用器中，如果当前没有连接成功（异步连接，返回false，说明客户端已经发送sync包，服务端没有返回ack包，物理链路还没有建立），示例代码如下：
if (connected)
{
clientChannel.register( selector, SelectionKey.OP_READ, ioHandler);
}
else
{
clientChannel.register( selector, SelectionKey.OP_CONNECT, ioHandler);
}
步骤五：向Reactor线程的多路复用器注册OP_CONNECT状态位，监听服务端的TCP ACK应答，示例代码如下：
clientChannel.register( selector, SelectionKey.OP_CONNECT, ioHandler);
步骤六：创建Reactor线程，创建多路复用器并启动线程，代码如下：
Selector selector = Selector.open();
New Thread(new ReactorTask()).start();
步骤七：多路复用器在线程run方法的无限循环体内轮询准备就绪的Key，代码如下：
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {
if (key.isConnectable())
//handlerConnect();
}
步骤九：判断连接结果，如果连接成功，注册读事件到多路复用器，示例代码如下：
if (channel.finishConnect())
registerRead();
步骤十：注册读事件到多路复用器：
clientChannel.register( selector, SelectionKey.OP_READ, ioHandler);
步骤十一：异步读客户端请求消息到缓冲区，示例代码如下：
int readNumber = channel.read(receivedBuffer);
步骤十二：对ByteBuffer进行编解码，如果有半包消息接收缓冲区Reset，继续读取后续的报文，将解码成功的消息封装成Task，投递到业务线程池中，进行业务逻辑编排，示例代码如下：
Object message = null;
while(buffer.hasRemain())
{
byteBuffer.mark();
Object message = decode(byteBuffer);
if (message == null)
{
byteBuffer.reset();
break;
}
messageList.add(message );
}
if (!byteBuffer.hasRemain())
byteBuffer.clear();
else
byteBuffer.compact();
if (messageList != null & !messageList.isEmpty())
{
for(Object messageE : messageList)
handlerTask(messageE);
}
步骤十三：将POJO对象encode成ByteBuffer，调用SocketChannel的异步write接口，将消息异步发送给客户端，示例代码如下：
完整代码：
package com.dxz.springsession.nio.demo6;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class NIOServer {
public static void main(String[] args) throws IOException {
new Thread(new ReactorTask()).start();
}
public static class ReactorTask implements Runnable {
private Selector selector;
public ReactorTask() {
try {
// 第一步：打开ServerSocketChannel，用于监听客户端的连接，它是所有客户端连接的父管道
ServerSocketChannel acceptorSvr = ServerSocketChannel.open();
// 第二步：病毒监听端口，设置连接为非阻塞模式
acceptorSvr.socket().bind(new InetSocketAddress(InetAddress.getByName("localhost"), 1234));
acceptorSvr.configureBlocking(false);
// 第三步：创建Reactor线程，创建多路复用器并启动线程
selector = Selector.open();
// 第四步：将ServerSocketChannel注册到Reactor线程的多路复用器Selector上，监听Accept事件
SelectionKey key = acceptorSvr.register(selector, SelectionKey.OP_ACCEPT);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
// 第五步：在run方法中无限循环体内轮询准备就绪的Key
while (true) {
try {
selector.select(1000);
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> it = selectedKeys.iterator();
SelectionKey key = null;
while (it.hasNext()) {
key = it.next();
it.remove();
try {
if (key.isValid()) {
// 处理新接入的请求消息
if (key.isAcceptable()) {
// 第六步：多路复用器监听到有新的客户端接入，处理新的接入请求，完成TCP三次握手，建立物理链路
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept();
// 第七步：设置客户端链路为非阻塞模式
sc.configureBlocking(false);
sc.socket().setReuseAddress(true);
// 第八步：将新接入的客户端连接注册到Reactor线程的多路复用器上，监听读操作，读取客户端发送的网络消息
sc.register(selector, SelectionKey.OP_READ);
}
if (key.isReadable()) {
// 第九步：异步读取客户端请求消息到缓存区
SocketChannel sc = (SocketChannel) key.channel();
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
int readBytes = sc.read(readBuffer);
// 第十步：对ByteBuffer进行编解码，如果有半包消息指针reset，继续读取后续的报文
if (readBytes > 0) {
readBuffer.flip();
byte[] bytes = new byte[readBuffer.remaining()];
readBuffer.get(bytes);
String body = new String(bytes, "UTF-8");
System.out.println("The time server receive order : " + body);
String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body)
? new java.util.Date(System.currentTimeMillis()).toString()
: "BAD ORDER";
//写应答
byte[] bytes2 = currentTime.getBytes();
ByteBuffer writeBuffer = ByteBuffer.allocate(bytes2.length);
writeBuffer.put(bytes2);
writeBuffer.flip();
sc.write(writeBuffer);
} else if (readBytes < 0) {
// 对端链路关闭
key.cancel();
sc.close();
} else
; // 读到0字节，忽略
}
}
} catch (Exception e) {
if (key != null) {
key.cancel();
if (key.channel() != null)
key.channel().close();
}
}
}
} catch (Throwable t) {
t.printStackTrace();
}
}
}
}
}
客户端：
package com.dxz.springsession.nio.demo6;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class TimeClientHandle implements Runnable {
private String host;
private int port;
private Selector selector;
private SocketChannel socketChannel;
private volatile boolean stop;
public TimeClientHandle(String host, int port) {
this.host = host == null ? "127.0.0.1" : host;
this.port = port;
try {
//第一步：打开SocketChannel,用于创建客户端连接
socketChannel = SocketChannel.open();
//第二步：设置SocketChannel为非阻塞模式
socketChannel.configureBlocking(false);
//第三步：创建多路复用器（在Reactor线程中）
selector = Selector.open();
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
}
@Override
public void run() {
try {
// 第四步：socketChannel发起连接
if (socketChannel.connect(new InetSocketAddress(host, port))) {
//第五步：如果直接连接成功，则注册到多路复用器上
socketChannel.register(selector, SelectionKey.OP_READ);
//第六步：发送请求消息，读应答
byte[] req = "QUERY TIME ORDER".getBytes();
ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
writeBuffer.put(req);
writeBuffer.flip();
socketChannel.write(writeBuffer);
if (!writeBuffer.hasRemaining())
System.out.println("Send order 2 server succeed.");
} else
socketChannel.register(selector, SelectionKey.OP_CONNECT);
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
while (!stop) {
try {
//第七步：多路复用器在run的无限循环体内轮询准备就绪的Key
selector.select(1000);
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> it = selectedKeys.iterator();
SelectionKey key = null;
while (it.hasNext()) {
key = it.next();
it.remove();
try {
if (key.isValid()) {
//第八步：将连接成功的Channel注册到多路复用器上
// 判断是否连接成功
SocketChannel sc = (SocketChannel) key.channel();
if (key.isConnectable()) {
if (sc.finishConnect()) {
sc.register(selector, SelectionKey.OP_READ);
//发送请求消息，读应答
byte[] req = "QUERY TIME ORDER".getBytes();
ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
writeBuffer.put(req);
writeBuffer.flip();
sc.write(writeBuffer);
if (!writeBuffer.hasRemaining())
System.out.println("Send order 2 server succeed.");
} else
System.exit(1);// 连接失败，进程退出
}
//监听读操作，读取服务端写回的网络信息
if (key.isReadable()) {
//第九步：读取信息到缓冲区
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
int readBytes = sc.read(readBuffer);
if (readBytes > 0) {
readBuffer.flip();
byte[] bytes = new byte[readBuffer.remaining()];
readBuffer.get(bytes);
String body = new String(bytes, "UTF-8");
System.out.println("Now is : " + body);
this.stop = true;
} else if (readBytes < 0) {
// 对端链路关闭
key.cancel();
sc.close();
} else
; // 读到0字节，忽略
}
}
} catch (Exception e) {
if (key != null) {
key.cancel();
if (key.channel() != null)
key.channel().close();
}
}
}
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
// 多路复用器关闭后，所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭，所以不需要重复释放资源
if (selector != null)
try {
selector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
package com.dxz.springsession.nio.demo6;
public class TimeClient {
/**
* @param args
*/
public static void main(String[] args) {
int port = 1234;
if (args != null && args.length > 0) {
try {
port = Integer.valueOf(args[0]);
} catch (NumberFormatException e) {
// 采用默认值
}
}
new Thread(new TimeClientHandle("127.0.0.1", port), "TimeClient-001")
.start();
}
}