Netty 源码解析 Part 0——第1篇：BIO vs NIO
- 前言 -
- BIO hello word -
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
*
* @author wangjianxin
*/
public class HelloBioServer {
public static void main(String[] args) throws IOException {
//创建ServerSocket
ServerSocket serverSocket = new ServerSocket();
//绑定到8000端口
serverSocket.bind(new InetSocketAddress(8000));
new BioServerConnector(serverSocket).start();
}
}
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
*
* @author wangjianxin
*/
public class BioServerConnector {
private final ServerSocket serverSocket;
public BioServerConnector(ServerSocket serverSocket) {
this.serverSocket = serverSocket;
}
public void start() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
Socket newSocket = null;
try {
//阻塞在这里等待新连接，返回值为一条新的连接
newSocket = serverSocket.accept();
} catch (IOException e) {
}
//将新连接交给handler处理
new BioServerHandler(newSocket).start();
}
}
});
thread.start();
}
}
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
*
* @author wangjianxin
*/
public class BioServerHandler {
private final Socket socket;
public BioServerHandler(Socket socket) {
this.socket = socket;
}
public void start() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
InputStream inputStream = socket.getInputStream();
byte[] buffer = new byte[1024];
//阻塞操作，因为不知道inputStream中什么时候会有数据可读，只能阻塞在这里等待
//每一个连接都要消耗一个线程
int readLength = inputStream.read(buffer);
if (readLength != -1) {
String name = new String(buffer, 0, readLength);
System.out.println(name);
//打印客户端发送过来的数据
socket.getOutputStream().write(("hello, " + name).getBytes());
}
} catch (Throwable e) {
try {
socket.close();
} catch (IOException ioException) {
}
}
}
}
});
thread.start();
}
}
HelloBioServer：启动类，创建一个ServerSocket，并交给BioServerConnetor处理 BioServerConnector：接受新连接的类，其中创建一个线程，循环阻塞在ServerSocket上等待新连接的到来，每建立一条新连接，就创建一个BioServerHandler，并将该连接交给BioServerHandler处理 BioServerHandler：处理连接上数据的类，每个BioServerHandler都创建一个线程循环阻塞在Socket的InputStream上，读取数据，再为该数据拼上“Hello, ”发送回去。
1.2 BIO客户端
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
*
* @author wangjianxin
*/
public class HelloBioClient {
//创建多少个客户端
private static final int CLIENTS = 2;
public static void main(String[] args) throws IOException {
for (int i = 0; i < CLIENTS; i++) {
final int clientIndex = i;
Thread client = new Thread(new Runnable() {
@Override
public void run() {
try {
//创建socket
Socket socket = new Socket();
//连接8000端口
socket.connect(new InetSocketAddress(8000));
while (true) {
OutputStream outputStream = socket.getOutputStream();
//向服务端发送”zhongdaima" + 客户端编号
outputStream.write(("zhongdaima" + clientIndex).getBytes());
InputStream inputStream = socket.getInputStream();
byte[] buffer = new byte[1024];
int readLength = inputStream.read(buffer);
//打印服务端返回数据
System.out.println(new String(buffer, 0, readLength));
Thread.sleep(1000);
}
} catch (Throwable e) {
}
}
});
client.start();
}
}
}
BIO客户端共1个类，HelloBioClient，在该客户端中创建了两个线程、两条连接，每个线程处理一条连接，循环向服务端发送“zhongdaima" + 客户端编号，并打印服务端返回的数据。
- NIO hello word -
2.1 NIO服务端
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
* @author wangjianxin
*/
public class HelloNioServer {
public static void main(String[] args) throws IOException {
//创建ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//设置Channel为非阻塞
serverSocketChannel.configureBlocking(false);
//绑定到8000端口
serverSocketChannel.bind(new InetSocketAddress(8000));
//交给Connector
new NioServerConnector(serverSocketChannel).start();
}
}
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
* @author wangjianxin
*/
public class NioServerConnector {
private final ServerSocketChannel serverSocketChannel;
private final Selector selector;
private final NioServerHandler nioServerHandler;
public NioServerConnector(ServerSocketChannel serverSocketChannel) throws IOException {
this.selector = Selector.open();
this.serverSocketChannel = serverSocketChannel;
//向selector注册Channel，感兴趣事件为OP_ACCEPT(即新连接接入)
this.serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT, serverSocketChannel);
this.nioServerHandler = new NioServerHandler();
this.nioServerHandler.start();
}
public void start() {
Thread serverConnector = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
if (NioServerConnector.this.selector.select() > 0) {
Set<SelectionKey> selectionKeys = NioServerConnector.this.selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
try {
if (key.isAcceptable()) {
//新连接接入
SocketChannel socketChannel = ((ServerSocketChannel) key.attachment()).accept();
socketChannel.configureBlocking(false);
//把新连接交给serverHandler
NioServerConnector.this.nioServerHandler.register(socketChannel);
}
} finally {
iterator.remove();
}
}
}
} catch (IOException e) {
}
}
}
});
serverConnector.start();
}
}
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
* @author wangjianxin
*/
public class NioServerHandler {
private final Selector selector;
private final BlockingQueue<SocketChannel> prepareForRegister = new LinkedBlockingDeque<>();
public NioServerHandler() throws IOException {
this.selector = Selector.open();
}
public void register(SocketChannel socketChannel) {
//这里为什么不直接注册呢，因为当有线程在selector上select时，register操作会阻塞
//从未注册过channel时，start方法中的线程会一直阻塞，在这里调用register的线程也会一直阻塞
//所以我们把待注册的channel放入队列中，并且换醒start方法中的线程，让start方法中的线程去注册
//放入待注册队列
try {
this.prepareForRegister.put(socketChannel);
} catch (InterruptedException e) {
}
//唤醒阻塞在selector上的线程（即下面start方法中创建的线程）
this.selector.wakeup();
}
public void start() {
Thread serverHandler = new Thread(new Runnable() {
@Override
public void run() {
try {
while (true) {
//只需要1个线程就可以监视所有连接
//当select方法返回值大于0时，说明注册到selector的Channels有我们感兴趣的事件发生
//返回值代表有多少Channel发生了我们感兴趣的事件
if (NioServerHandler.this.selector.select() > 0) {
//紧接着调用selectedKeys方法获取发生事件的Key集合
Set<SelectionKey> selectionKeys = NioServerHandler.this.selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
//遍历Key集合，处理Channel io事件
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
try {
if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.attachment();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int readLength = socketChannel.read(buffer);
buffer.flip();
System.out.println(new String(buffer.array(), 0, readLength));
socketChannel.write(ByteBuffer.wrap(("hello, " + new String(buffer.array(), 0, readLength)).getBytes()));
}
} finally {
iterator.remove();
}
}
}
SocketChannel socketChannel;
while ((socketChannel = NioServerHandler.this.prepareForRegister.poll()) != null) {
//注册待注册的channel，感兴趣事件为OP_READ(即可读事件)
socketChannel.register(NioServerHandler.this.selector, SelectionKey.OP_READ, socketChannel);
}
}
} catch (IOException e) {
}
}
});
serverHandler.start();
}
}
和BIO服务端类似，NIO服务端也有3个类，分别是HelloNioServer、NioServerConnector和NioServerHandler。
HelloNioServer：启动类，创建一个ServerSocketChannel，将Channel设置为非阻塞的，绑定到8000端口，交给Connector处理。到这里我们应该明白了为什么NIO是none blocking io，这里比BIO多了一步操作，即将Channel设置为非阻塞的。具体哪里体现出了非阻塞，我们继续往下看。
NioServerConnector：处理新连接的类，该类接收一个ServerSocketChannel，创建一个Selector，并向Selector注册Channel，感兴趣事件为OP_ACCEPT（即新连接接入），并创一个NioServerHandler的实例。NioServerConnector的start方法中创建一个线程，循环向selector询问是否有新连接接入，一旦发现有新连接接入，就把新连接交给NioServerHandler处理。这里与BIOServerConnector中不同的是，有新连接接入时，不必再创建一个新的Handler，而是所有连接共用一个Handler。
NioServerHandler：处理连接数据上类，该类start方法中创建一个线程循环向Selector询问是否有可读事件发生。一旦某些连接上有可读事件发生，就读取这些连接上的数据，并为该数据添加上“Hello, ”再发送回去。然后再处理新的连接注册，将新连接注册到Selector上，感兴趣事件为OP_READ（即可读事件）。与BioServerHandler不同的是BioServerHandler中一个线程只能处理一条连接，而NioServerHandler中一个线程可以处理多条连接。
好了，至此我们已经看到了NIO的非阻塞体现在socketChannel.read()方法是非阻塞的，而BIO的阻塞体现在inputstream.read()方法是阻塞的。
2.2 NIO客户端
/**
* 欢迎关注公众号“种代码“，获取博主微信深入交流
*
* @author wangjianxin
*/
public class HelloNioClient {
private static final int CLIENTS = 2;
public static void main(String[] args) throws IOException {
Thread client = new Thread(new Runnable() {
final Selector selector = Selector.open();
final SocketChannel[] clients = new SocketChannel[CLIENTS];
@Override
public void run() {
//创建两个客户端
for (int i = 0; i < CLIENTS; i++) {
try {
//连接8000端口
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress(8000));
//将channel设置为非阻塞的
socketChannel.configureBlocking(false);
//注册到selector
socketChannel.register(this.selector, SelectionKey.OP_READ, socketChannel);
//保存channel
clients[i] = socketChannel;
}catch (Throwable e){
}
}
for (int i = 0; i < Integer.MAX_VALUE; i++) {
try {
//向服务端发送“zhongdaima" + 客户端编号
for (int j = 0; j < clients.length; j++) {
this.clients[j].write(ByteBuffer.wrap(("zhongdaima" + j).getBytes()));
}
//监视Channel是否有可读事件发生
if (this.selector.select() > 0) {
Set<SelectionKey> selectionKeys = this.selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()){
SelectionKey key = iterator.next();
try {
SocketChannel channel = (SocketChannel) key.attachment();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int read = channel.read(buffer);
buffer.flip();
//打印服务端返回数据
System.out.println(new String(buffer.array(), 0, read));
}finally {
iterator.remove();
}
}
}
Thread.sleep(1000);
}catch (Throwable e){
}
}
}
});
client.start();
}
}
NIO客户端只有一个类HelloNioClient，其中创建一个线程、两条连接，循环向服务端发送“zhongdaima" + 客户端编号，然后向Selctor循问是否有可读事件发生，一旦有可读事件发生，就读取数据，并打印。与HelloBioClient不同的是HelloNioClient创建了两条连接，却只使用了一个线程，而HelloBioClient中创建了两条连接，使用了两个线程。
- 相比 BIO，NIO 有哪些优势？ -
读到这里，大家仔细品品NIO比BIO的优势在哪里。优势在哪里呢，要首先看看有什么区别，上面的代码具体有什么区别我都加粗表示了，看完之后第一感觉应该就是NIO比BIO节省线程。
3.1 BIO模型
这是BIO的示意图，比较简单，每条连接都需要一个线程来处理，因为无法得得连接中什么时候有数据可以读取，只能傻傻等待。
3.2 NIO模型
这是NIO的示意图，与BIO相比，其中多了一个组件Selector。正是由于Selector的存在让NIO与BIO产生了本质的不同。BIO中线程直接阻塞在1条连接上，直到有数据可读取才返回，而且NIO中线程首先阻塞在Selector上，而Selector上可以注册多条连接。
线程调用select方法向Selector询问是否有感兴趣的事件发生，阻塞在select方法上，直接到1条或者多条连接上有事件发生才返回。此时线程已经知道哪些连接上有事件发生了，于是去处理这些连接上的事件。处理完成之后再次阻塞在Selector的select方法上，如此往复。
至此我们已经发现，BIO和NIO的本质不同在于中间多了一层代理Selector，而Selector具备监视多条连接的能力。
3.3 举个例子
开一家BIO模型的饭店，饭店里只有1个厨师（相当于Thread），有1位顾客（相当于连接）来吃饭，厨师就一直为这1位顾客做饭，直到这个顾客结账走了（连接关闭），厨师才开始为下1位顾客做饭。如果需要同时满足10个顾客吃饭，就要10个厨师。
开一家NIO模型的饭店，饭店里有1个厨师（相当于Thread），还有1个服务员（相当于Selector），有10位顾客来吃饭，服务员就为这10位顾客点餐（向Selector注册），并且需要知道顾客你们都点什么菜（向Selector注册时的兴趣事件）。厨师问服务员顾客都点了什么菜（Selector.select()），开始做菜，做完菜之后再问服务员顾客们又点了什么菜，如此往复。只需要1个厨师、1个服务员就可以为多个顾客提供服务。
很显然，如果你开饭店，你是开BIO饭店呢，还是NIO饭店呢。
- 总结 -
NIO的非阻塞体现在socketChannel.read()方法是非阻塞的，而BIO的阻塞体现在inputstream.read()方法是阻塞的。
NIO一个线程可以处理多条连接，而BIO一个线程只能处理一条连接，NIO更节省线程资源。
作者：王建新，转转架构部资深Java工程师，主要负责服务治理、RPC框架、分布式调用跟踪、监控系统等。
来源公众号：种代码
