BIO、NIO

---

1. BIO和NIO

我们平常使用的IO是BIO（Blocking-IO），即阻塞IO、而NIO（No-blocking-IO）则是非阻塞IO，二者有什么区别呢？

预先知识准备

• 同步：发起调用后，调用者一直处理任务至结束后才返回结果，期间不能执行其他任务
• 异步：发起调用后，调用者立即返回结果的标记（当结果出来后用回调等机制通知），期间可以执行其他任务
• 阻塞：发起请求后，发起者一直等待结果返回，期间不能执行其他任务
• 非阻塞：发起请求后，发起者不用一直等待结果，期间可以执行其他任务
• IO模式有五种（BIO、NIO、信号驱动IO、多路复用IO、异步IO）这里介绍同步阻塞和同步非阻塞IO，而剩下的后面回来填坑

NIO主要体现在网络IO中，所以下面就围绕网络IO来说明，这里会涉及到传统的BIO、网络编程、反应器设计模式，如果不了解的童鞋这里有各自的传送门 BIO ，[未完善]

二者区别

	BIO	NIO
类型	同步阻塞	同步非阻塞
面向	面向流	面向缓冲区
组件	无	选择器

若没有了解过NIO，那么列出的区别只需有个印象即可，后面会逐步说明

2.BIO

2.1 传统BIO

传统的IO其读写操作都阻塞在同一个线程之中，即在读写期间不能再接收其他请求

那么我们就来看看传统BIO是怎么实现的，后面都以网络编程的Socket为例，因其与后面的NIO有关

public class BIO {

	public static void main(String[] args) throws IOException {

		// 开个线程运行服务器端套接字
		new Thread( () -> {
			try {
                // 建立服务器端套接字
                ServerSocket serverSocket = new ServerSocket(8080);
                // 该方法阻塞至有请求过来
                Socket socket = serverSocket.accept();

                // 获取输入流
                int length = 0;
                byte[] bytes = new byte[1024];
                InputStream in = socket.getInputStream();

                // 客户端关闭输出流这里才会读取到-1,shutdownOutput或者close
                while( (length = in.read(bytes)) != -1){
                    System.out.println(new String(bytes,0,length));
                }

                System.out.println("这里服务器端处理任务花费了10秒");
                Thread.sleep(10000);

                // 获取输出流
                OutputStream out = socket.getOutputStream();
                out.write( ("这里是服务器端发送给客户端的消息: " + new Date()).getBytes() );

                // 关闭资源
                in.close();
                out.close();
                socket.close();
                serverSocket.close();
			} catch (Exception e) {
			}
		}).start();

		// 开个线程运行客户端套接字
		new Thread( () -> {
			try {
				// 建立客户端套接字
				Socket socket = new Socket("127.0.0.1",8080);

				// 获取输出流
				OutputStream out = socket.getOutputStream();
				out.write( ("这里是客户端发送给服务器端的消息：" + new Date()).getBytes() );
				// 关闭输出流,让服务器知道数据已经发送完毕，剩下接收数据了
				socket.shutdownOutput();

				// 获取输入流
				int length = 0;
				byte[] bytes = new byte[1024];
				InputStream in = socket.getInputStream();
				while( (length = in.read(bytes)) != -1){
					System.out.println(new String(bytes,0,length));
				}

				// 关闭资源，若没有关闭则会保持连接至超时，单线程服务器端就不能接收后来的连接请求
				out.close();
				in.close();
				socket.close();
			} catch (Exception e) {
			}
		}).start();

	}
}

这里是客户端发送给服务器端的消息：Sat Feb 08 15:14:55 GMT+08:00 2020
这里服务器端处理任务花费了10秒
这里是服务器端发送给客户端的消息: Sat Feb 08 15:15:05 GMT+08:00 2020

• 从输出可以看出，客户端会一直等待阻塞直至服务器端返回内容

• 服务器端的accept()方法会阻塞当前线程，直至有请求发送过来才会继续accept()方法下面的代码

• 服务器端接收到一个请求后且该请求还没处理完，后又再有一个请求过来，则后来的请求会被阻塞需排队等待

• 客户端打开输出流若没关闭，则服务器端是不知道客户端数据已经发送完，会一直等待至超时 ，关闭方法：

  • 客户端socket.close()，整个连接也关闭了
  • 客户端socket.shutdownOutput()，单方面关闭输出流，不关闭连接
  • 客户端的outputStream.close()，会造成socket被关闭

2.2 伪异步BIO

传统的BIO是单线程的，一次只能处理一个请求，而我们可以改进为多线程，即服务器端每接收到一个请求就为该请求单独创建一个线程，而主线程还是继续监听是否有请求过来，伪异步是因为accept方法到底还是同步的

public class SocketTest {

	// 定义线程接口
	class MyRunnable implements Runnable{

		@Override
		public void run(){
			try {
				Socket socket = new Socket("127.0.0.1",8080);

				// 获取输出流
				OutputStream out = socket.getOutputStream();
				out.write( ("这里是客户端发送给服务器端的消息：" + new Date()).getBytes() );
				// 关闭输出流,让服务器知道数据已经发送完毕，剩下接收数据了
				socket.shutdownOutput();

				// 获取输入流
				int length = 0;
				byte[] bytes = new byte[1024];
				InputStream in = socket.getInputStream();
				while( (length = in.read(bytes)) != -1){
					System.out.println(new String(bytes,0,length));
				}

				// 关闭资源
				out.close();
				in.close();
				socket.close();
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) throws IOException, InterruptedException {

		// 开个线程运行服务器端套接字
		new Thread( () -> {
			try {
				// 建立服务器端套接字
				ServerSocket serverSocket = new ServerSocket(8080);

				// 循环接收请求
				while(true){
					Socket socket = serverSocket.accept();

					// 为每个请求单独开线程，这里就不那么复杂使用线程池了
					new Thread( () -> {
						try {
							// 获取输入流
							int length = 0;
							byte[] bytes = new byte[1024];
							InputStream in = socket.getInputStream();
							while( (length = in.read(bytes)) != -1){
								System.out.println(new String(bytes,0,length));
							}

							// 获取输出流
							OutputStream out = socket.getOutputStream();
							out.write( ("这里是服务器端发送给客户端的消息: " + new Date()).getBytes() );

							// 关闭资源
							in.close();
							out.close();
							socket.close();
						} catch (Exception e) {
							// TODO: handle exception
						}
					}).start();
				}
			} catch (Exception e) {
			}
		}).start();

		// 创建多线程，调用类中接口（为了偷懒写成这样了。。。）
        // 关注点在于伪异步，像线程计数器，，线程池，Lambda表达式也尽量少用，使代码易懂
		SocketTest socketTest = new SocketTest();
		MyRunnable myRunnable = socketTest.new MyRunnable();
		new Thread(myRunnable).start();
		new Thread(myRunnable).start();
		new Thread(myRunnable).start();

	}
}

这里是客户端发送给服务器端的消息：Sat Feb 08 15:52:00 GMT+08:00 2020
这里是服务器端发送给客户端的消息: Sat Feb 08 15:52:00 GMT+08:00 2020
这里是客户端发送给服务器端的消息：Sat Feb 08 15:52:00 GMT+08:00 2020
这里是客户端发送给服务器端的消息：Sat Feb 08 15:52:00 GMT+08:00 2020
这里是服务器端发送给客户端的消息: Sat Feb 08 15:52:00 GMT+08:00 2020
这里是服务器端发送给客户端的消息: Sat Feb 08 15:52:00 GMT+08:00 2020

• 服务器端每来一个请求就为之单独创建线程来处理任务，使主线程可以继续循环接收请求
• 客户端的请求之间就互不干扰了，不用等待上一个请求处理完才处理下一个
• 其本质还是同步，使用了多线程才实现异步功能
• 使用多线程，若在多高并发情况下，会大量创建线程而导致内存溢出（可以使用线程池优化，但有界限池终究不是办法）

3. NIO

• 看了上面那么多铺垫，终于到我们的正题了。NIO主要使用在网络IO中，当然文件IO也有使用，NIO在高并发的网络IO中有极大的优势，其在JDK1.4中引入，以我们传统再传统的开发环境--1.7中可以使用了
• 在单线程中，NIO在写读数据的时候可以同时执行其他任务，不必等数据完全读写而导致阻塞（后面有地方说明）

NIO的组成

• Buffer（缓冲区）
• Channel（通道）
• Selector（选择器）

那么我们就来看看NIO的三个组成把

3.1 Buffer

NIO是面向缓冲区的，一次处理一个区的数据，在NIO中我们都是使用缓冲区来处理数据，即数据的读入或写出都要经过缓冲区

缓冲区的类型有：

• ByteBuffer、

• ShortBuffer、

• IntBuffer、

• LongBuffer、

• FloatBuffer、

• DoubleBuffer、

• CharBuffer

最常用是ByteBuffer，记住后面要用到，可使用静态方法获取缓冲区：ByteBuffer.allocate(1024)

Buffer类中主要的方法：

返回类型	函数	解释
XXXBuffer	allocate(int capacity)	返回指定容量的缓冲区
ByteBuffer	put(byte[] src)	向缓冲区添加字节数组
ByteBuffer	get(byte[] dst)	向缓冲区获取字节数组
XXXBuffer	flip()	切换成读模式
XXXBuffer	clear()	清除此缓冲区

其内部维护了几个变量

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;	// 标记这里不讲解
private int position = 0;	//位置
private int limit;		// 限制
private int capacity;	// 容量大小

变量的变化：

初始化时：position为0，limit和capacity为容量大小，且capacity不变化，后面省略

put数据时：position为put进去数据大小（如放进5字节数据，则position=5），其余不变，正常默认为写模式

切换读模式：limit赋值为position的当前值，而position赋值为0

get数据时：读取多少个数据，position就前进几个位置

清空：调用clear()，变量变为初始化状态，即position为0，limit为容量大小

3.2 Channel

通道主要是传输数据的，不进行数据操作，并且与流不同可以前后移动，而且通道是双向的读写的，最重要的是Channel只能与Buffer交互，所以要使用NIO就要用Channel和Buffer来配合

其类型包括：

• FileChannel
• DatagramChannel
• SocketChannel:
• ServerSocketChannel

可以看出NIO主要支持网络IO及文件IO，可通过静态方法获取：ServerSocketChannel.open()，然后通过ServerSocketChannel.socket()获取对应的套接字，套接字的获取通道方法前提是已经绑定了通道才行，不然空指针

通道的主要方法：

类型	函数名	解释
ServerSocketChannel	open	返回对应的通道
int	read(ByteBuffer dst)	从该通道读取到给定缓冲区的字节序列
int	write(ByteBuffer src)	从给定的缓冲区向该通道写入一个字节序列
ServerSocketChannel	bind(SocketAddress local)	将通道的套接字绑定到本地，设为监听连接
SelectableChannel	configureBlocking(Boolean bool)	设置通道的阻塞模式
SelectionKey	register(Selector sel, int ops)	将通道注册到选择器

配合Channel和Buffer来简单实现数据流通

int length = 0;
while( (length = inChannel.read()) != -1 ){
    buffer.flip();	//切换读模式
    outChannel.write(buffer);	// 数据写入通道
    buffer.clear();		// 清空缓冲区，实现可再写入
}

3.3 Selector

NIO特有的组件（选择器容器），注意只有在网络IO中才具有非阻塞性，网络IO中的套接字的通道才有非阻塞的配置。使用单线程通过Selector来轮询监听多个Channel，在IO事件还没到达时不会陷入阻塞态等待。划重点：传统BIO在事件还没到达时该线程会被阻塞而等待，一次只能处理一个请求（可以使用多线程来提高处理能力）。而NIO在事件还没到达是非阻塞轮询监听的，一次可以处理多个事件。使用一个线程来处理多个事件明显比一个线程处理一个事件更优秀，获取选择器：Selector.open()

选择器主要方法：

类型	方法名	解释
void	close	关闭此选择器
Selector	open	打开选择器
int	select	选择一组准备好的IO键
Set	selectedKeys	返回选择器的键集

这里补充一下注册通道时返回的键的方法

XXXChannel	channel	返回键对应的通道，类似于句柄
boolean	isAcceptable	键对应的通道是否准备好了
boolean	isReadable	键对应的通道是否可读
boolean	isWritable	键对应的通道是否可写

3.4 使用事例

综合上面BIO的 2.1和 2.2的代码，客户端基本不用改动，使用多线程来模拟多次请求，而重点改造在于服务器端

这里的服务器端用单线程来处理请求，即一对多使用了多路复用。若是BIO单线程则会阻塞，即一请求一应答

public class NIOTest {0.

	// 定义线程接口
		class MyRunnable implements Runnable{

			@Override
			public void run(){
				try {
					Socket socket = new Socket("127.0.0.1",8080);

					// 获取输出流
					OutputStream out = socket.getOutputStream();
					out.write( ("这里是客户端发送给服务器端的消息：" + new Date()).getBytes() );
					// 关闭输出流,让服务器知道数据已经发送完毕，剩下接收数据了
					socket.shutdownOutput();

					// 获取输入流
					int length = 0;
					byte[] bytes = new byte[1024];
					InputStream in = socket.getInputStream();
					while( (length = in.read(bytes)) != -1){
						System.out.println(new String(bytes,0,length));
					}

					// 这里故意不关闭资源，保持连接
					// 如果是BIO单线程，没有断开连接，则会阻塞后面的请求
					// 而NIO则不会阻塞，因为是多路复用

				} catch (Exception e) {
				}
			}
		}

	public static void main(String[] args) throws UnknownHostException, IOException {

		// 开个线程运行服务器端套接字
		new Thread( () -> {

			try {
				// 静态方法获取选择器
				// 开启选择器的线程会被选择器阻塞，所以要另开一个线程执行
				Selector selector = Selector.open();

				// 获取服务器端通道并配置非阻塞
				ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
				serverSocketChannel.configureBlocking(false);
				InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
				serverSocketChannel.bind(inetSocketAddress);

				// Selector管理Channel，则需将对应的channel注册上去，且指定类型
				// 将服务器通道注册到选择器上,注册为accept
				// 可频道为：一看能看出来不解释了
				/**
				 * SelectionKey.OP_CONNECT
				 * SelectionKey.OP_ACCEPT
				 * SelectionKey.OP_READ
				 * SelectionKey.OP_WRITE
				 */
				serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

				while(true){
					// 轮询监听是否有准备好的连接
					if(selector.select() > 0){
						// 获取键集
						Set<SelectionKey> set = selector.selectedKeys();
						Iterator iterator = set.iterator();
						// 迭代器迭代
						while(iterator.hasNext()){
							SelectionKey selectionKey = (SelectionKey) iterator.next();

							// 接收连接事件
							if(selectionKey.isAcceptable()){
								SocketChannel socketChannel = serverSocketChannel.accept();

								// 设置客户端通道为非阻塞，不然选择器会被阻塞，其存在没有意义了
								socketChannel.configureBlocking(false);

								// 将客户端通道注册到选择器上，使选择器可以统一管理
								socketChannel.register(selector, SelectionKey.OP_READ);

							// 处理可读事件
							}else if(selectionKey.isReadable()){
								// 通过key来获取通道
								SocketChannel socketChannel = (SocketChannel) selectionKey.channel();

								// 配合缓冲区
								ByteBuffer bytebuffer = ByteBuffer.allocate(1024);

								int length = 0;
								byte[] bytes = new byte[1024];
								while( (length = socketChannel.read(bytebuffer)) != -1){
									bytebuffer.flip();

									// 将缓冲区数据放入字节数组，并输出
									bytebuffer.get(bytes, 0, length);
									System.out.println(new String(bytes,0,length));

									bytebuffer.clear();
								}
							}
							// 取消选择键，因为有些已经处理了
							iterator.remove();
						}
					}
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}).start();

		// 调用类中接口，创建多线程（为了偷懒写成这样了。。。）
		NIOTest NIOTest = new NIOTest();
		MyRunnable myRunnable = NIOTest.new MyRunnable();
		new Thread(myRunnable).start();
		new Thread(myRunnable).start();
		new Thread(myRunnable).start();

	}
}

• 上面客户端故意不关闭连接，未超时情况下也能处理多请求，则说明NIO是非阻塞的，最大好处就在于这里

总结

挖坑：AIO异步的IO，基于网络编程的Netty框架，越来越多的坑要填了 —_—!