BIO、NIO

2019/04/10 10:10
阅读数 12

<br>

1. BIO和NIO

我们平常使用的IO是BIO(Blocking-IO),即阻塞IO、而NIO(No-blocking-IO)则是非阻塞IO,二者有什么区别呢?

<br>

预先知识准备

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

<br>

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

<br>

二者区别

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

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

<br> <br>

2.BIO

<br>

2.1 传统BIO

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

<br>

那么我们就来看看传统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被关闭

<br> <br>

2.2 伪异步BIO

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

<br>

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

<br> <br> <br> <br>

3. NIO

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

<br>

NIO的组成

  • Buffer(缓冲区)
  • Channel(通道)
  • Selector(选择器)

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

<br> <br>

3.1 Buffer

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

<br>

缓冲区的类型有:

  • ByteBuffer、

  • ShortBuffer、

  • IntBuffer、

  • LongBuffer、

  • FloatBuffer、

  • DoubleBuffer、

  • CharBuffer

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

<br>

Buffer类中主要的方法:

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

<br>

其内部维护了几个变量

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

<br>

变量的变化:

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

put数据时:position为put进去数据大小(如放进5字节数据,则position=5),其余不变,正常默认为写模式

切换读模式:limit赋值为position的当前值,而position赋值为0

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

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

<br> <br>

3.2 Channel

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

<br>

其类型包括:

  • FileChannel
  • DatagramChannel
  • SocketChannel:
  • ServerSocketChannel

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

<br>

通道的主要方法:

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

<br>

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

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

<br> <br>

3.3 Selector

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

<br>

<br>

选择器主要方法:

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

<br>

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

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

<br> <br>

3.4 使用事例

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

<br>

这里的服务器端用单线程来处理请求,即一对多使用了多路复用。若是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是非阻塞的,最大好处就在于这里

<br> <br>

总结

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

<br> <br> <br> <br>

原文出处:https://www.cnblogs.com/Howlet/p/12286670.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部