【Netty入门和实践】2.NIO的样例代码分析

上一篇我们介绍了传统IO的网络信息传输方式，分析出了传统IO网络传输的一些缺点，下面我们就介绍一下基于新型IO的网络传输方式，来弥补传统IO的不足。

NIO的官方介绍：
NIO全称java non-blocking IO，是指jdk1.4 及以上版本里提供的新api（New IO） ，为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。

我们先通过一个代码实例进行了解。在之前的“IOServer”工程下创建一个“cn.com.io.nio”包，然后新建一个名为“New_IO_Server”的类：

该类代码如下：

package cn.com.io.nio;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;


public class New_IO_Server {
    //通道通信
	private Selector selector;
	
	/**
	 * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
	 * @param port 绑定的端口号
	 * @throws IOException
	 * */
	public void initServer(int port) throws IOException {
		//获得一个ServerSocket通道
		ServerSocketChannel serverChannel = ServerSocketChannel.open();
		//设置通道为非阻塞
		serverChannel.configureBlocking(false);
		//将通道对应的ServerSocket绑定到port端口
		serverChannel.socket().bind(new InetSocketAddress(port));
		//获得一个通道管理器
		this.selector = Selector.open();
		//将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件，注册该事件后，
		//当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞
		serverChannel.register(selector, SelectionKey.OP_ACCEPT);
	}
	
	/**
	 * 采用轮询的方式监听selector是否有需要处理的事件，如果有，则进行处理
	 * @throws IOException
	 * */
	public void listen() throws IOException{
		System.out.println("服务端启动成功！");
		//轮询访问selector
		while(true){
			//当注册的事件到达时，方法返回；否则，该方法会一直阻塞
			selector.select();
			//获得selector中选中的项的迭代器，选中的项为注册的事件
			Iterator<?> ite = this.selector.selectedKeys().iterator();
			while(ite.hasNext()){
				SelectionKey key = (SelectionKey)ite.next();
				//删除已选的key，以防重复处理
				ite.remove();
				handler(key);
			}
		}
	}
	
	/**
	 * 处理请求
	 * @param key
	 * @throws IOException
	 * */
	private void handler(SelectionKey key) throws IOException{
		if(key.isAcceptable()){//客户端请求连接事件
			handlerAccept(key);
		}else if(key.isReadable()){//获得了可读的事件
			handlerRead(key);
		}
	}


	/**
	 * 处理连接请求
	 * @param key
	 * @throws IOException
	 * */
	private void handlerAccept(SelectionKey key) throws IOException {
		//获得ServerSocket
		ServerSocketChannel server = (ServerSocketChannel) key.channel();
		//获得和客户端连接的通道
		SocketChannel channel = server.accept();
		//设置成非阻塞
		channel.configureBlocking(false);
		
		System.out.println("新的客户端连接");
		//服务端发给客户端的确认信息
		channel.write(ByteBuffer.wrap("服务端成功创建连接".getBytes()));
		//在和客户端连接成功后，为了可以接收到客户端的信息，需要给通道设置读的权限
		channel.register(this.selector, SelectionKey.OP_READ);
	}


	/**
	 * 处理可读的事件
	 * @param key
	 * @throws IOException
	 * */
	private void handlerRead(SelectionKey key) throws IOException {
		//得到事件发生的Socket通道
		SocketChannel channel = (SocketChannel) key.channel();
		//创建读取的缓冲区(每次读1000个字节)
		ByteBuffer buffer = ByteBuffer.allocate(1000);
		channel.read(buffer);
		byte[] data = buffer.array();
		String msg = new String(data).trim();
		System.out.println("服务端收到信息："+msg);
		
		ByteBuffer outBuffer = ByteBuffer.wrap(("服务端收到信息："+msg).getBytes());
		channel.write(outBuffer);//将消息送回给客户端
	}
	
	/**
	 * 启动服务测试
	 * @throws IOException
	 * */
	public static void main(String[] args) throws IOException {
		New_IO_Server server = new New_IO_Server();
		server.initServer(10010);
		server.listen();
	}
}

在上面的代码中，出现了许多与传统IO不同的API，其中ServerSocketChannel类似传统IO的ServerSocket，而SocketChannel类似传统IO的Socket。而出现的Selector以及SelectionKey相当于“选择器”和“选择事件类型”。是用来让一个单独的线程来“选择”通道的，这种选择机制，使得一个单独的线程很容易来管理多个通道。

我们来简单分析一下上面的代码：
在启动服务的main方法中可以看到，一开始我们调用了initServer方法用于初始化服务端信息，做了以下事情：
(1)打开一个ServerSocket通道，并设置为非阻塞
(2)将通道对应的ServerSocket绑定到port端口，这个端口就是服务端对外服务的端口
(3)然后获得一个通道管理器，并注册一个SelectionKey.OP_ACCEPT事件，用于监听
客户端发送过来的不同类型的请求。

然后又调用了listen进行客户端监听，采取轮询的方式监听selector是否有需要处理的事件，
如果有，则进行处理。
这里监听的就是两种主要请求类型：
(1)连接请求：客户端对服务端的连接请求
(2)数据读取：客户端向服务端发送了信息，服务端接受并解析

处理连接请求就进行通道获取和阻塞类型设置，并设置通道读的权限。
处理可读事件就创建缓冲区读取客户端信息。

形象一点，整个过程就是，服务端(餐厅)初始化一个(服务员)selector(选择器，用于服务所有客户端)，注册一个OP_ACCEPT的KEY(老板口头交代服务员要接待大门进来的新客人)，意味着出现连接事件(客人来)的时候，selector需要去处理连接事件(接待客人)，并听取客户端的各种信息(建立连接还是点菜)，当接受连接请求类型(找位子准备点餐)时，为客户端进行注册(准备接受客户点菜)；当接受读取事类型(顾客点菜)时，听取客户端(顾客)的具体点餐信息。

在NIO中可以设置每个连接通道为“非阻塞”状态，这就意味着使用一个单线程，就可以开启多个客户端进行服务端的连接，不存在一个客户端一直占用单线程的情况。我们运行上面的代码，使用CMD的telnet试验一下：

发现是可以同时连接服务端的。

------摘自：https://www.cnblogs.com/xiaoxi/p/6576588.html------
下表总结了Java IO和NIO之间的主要区别：
IO         NIO
面向流 面向缓冲
阻塞IO 非阻塞IO
无         选择器
 
1、面向流与面向缓冲
     Java IO和NIO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 
     Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方：
     
     此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。
     Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性：
     
     但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。


2、阻塞与非阻塞IO
     Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了：
     
     Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 
     
     非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

3、选择器（Selectors）
     Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。
------摘自：https://www.cnblogs.com/xiaoxi/p/6576588.html------

对于传统IO和NIO，网上有一对图片表达的非常好：

我们的系统就相当于一个餐厅，大门相当于ServerSocket，客人相当于socket客户端，服务员相当于每个socket客户端的处理线程。当在多线程的情况下处理客户端的时候，就相当于餐厅每一个客人都配备了一个专门的服务员，这不管对系统还是餐厅，都是很大的开销。

而对于NIO：

这里也是将系统比喻为一个餐厅，大门相当于serverChannel.socket().bind(new InetSocketAddress(10010))，客人相当于SocketChannel客户端，服务员相当于线程和selector，只需要一个服务员就可以服务所有的客人了，这对于系统或餐厅来说都是一个低开销的事情。

转载请注明出处:https://blog.csdn.net/acmman/article/details/80039201