JAVA NIO（四）阻塞式IO与非阻塞式IO

最新推荐文章于 2024-03-28 21:28:52 发布
最新推荐文章于 2024-03-28 21:28:52 发布
阅读量408 收藏 1
点赞数
分类专栏： JavaBase 文章标签： BIO NIO 阻塞式IO与非阻塞式IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dason_yu/article/details/79541867
版权

1.阻塞与非阻塞

IO模型：

由于进程是不可直接访问外部设备的，所以只能调用内核去调用外部的设备(上下文切换)，然后外部设备比如磁盘，读出存储在设备自身的数据传送给内核缓冲区，内核缓冲区在copy数据到用户进程的缓冲区。包含两个步骤：一将数据读到内核，二将数据从内核copy用户地址空间（即应用程序）。

① 阻塞与非阻塞：是针对于网络通讯而言。应用程序在获取网络数据的时候，根据IO操作的就绪状态来采取的不同方式。说白了是一种读取或者写入操作函数的实现方式。 （即在服务端accept()时，若数据没有准备就绪，则程序被阻塞）
（运行一个应用程序，就启动了一个用户进程，操作系统的核心是内核进程）
阻塞：应用程序在获取网络数据的时候，如果网络传输数据很慢，那么程序就一直等着，知道传输完毕为止。
非阻塞：应用程序直接获取数据无需等待。读取或者写入函数会立即返回一个状态值。

阻塞IO模型：

在等待数据时，进程被挂起（就像线程中的wait()）,知道数据就绪。


非阻塞IO模型

非阻塞是指在内核请求IO设备响应指令发出后，数据就开始准备，在此期间用户进程没有阻塞，也就是没有挂起，它一直在询问或者check数据有没有传送到kernel buffer（内核）中，忙等…。但是第二个阶段（数据从kernel buffer复制到用户进程空间）依然是阻塞的。但这种IO模型会大量的占用CPU的时间，效率很低效，很少使用。


IO多路复用

在内核请求IO设备响应指令发出后，数据就开始准备，在此期间用户进程是阻塞的。数据从kernel buffer复制到用户进程的过程也是阻塞的。但是和阻塞I/O所不同的是，它可以同时阻塞多个I/O操作，而且可以同时对多个读操作，多个写操作的I/O函数进行检测，直到有数据可读或可写时，才真正调用I/O操作函数，也就是说一个线程可以响应多个请求。（在IO multiplexing Model中，实际中，对于每一个socket，一般都设置成为non-blocking，但是，如下图所示，整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block）
弊端：
select 如果任何一个sock(I/O stream)出现了数据，select 仅仅会返回，但是并不会告诉你是那个sock上有数据，于是你只能自己一个一个的找，10几个sock可能还好，要是几万的sock每次都找一遍，这个无谓的开销就颇有海天盛筵的豪气了。



② 选择器

选择器（Selector） 是 SelectableChannel 对象的多路复用器，Selector 可以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector 可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心。

（举栗：比如说数据就绪，当有数据就绪服务端才会进行accept()；如图所示）



当调用 register(Selector sel, int ops) 将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数 ops 指定。
可以监听的事件类型（可使用 SelectionKey 的四个常量表示）：
 读 : SelectionKey.OP_READ （1）
 写 : SelectionKey.OP_WRITE （4）
 连接 : SelectionKey.OP_CONNECT （8）
 接收 : SelectionKey.OP_ACCEPT （16）
 若注册时不止监听一个事件，则可以使用“位或”操作符连接。

ssChannel.register(selector, SelectionKey.OP_ACCEPT | SelectionKey.OP_CONNECT);
常用方法

③ SelectionKey
表示 SelectableChannel 和 Selector 之间的注册关系。每次向选择器注册通道时就会选择一个事件(选择键)。选择键包含两个表示为整数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操作。
常用方法

2.阻塞IO

package com.dason.nio2;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import org.junit.Test;

/*
 * 一、使用 NIO 完成网络通信的三个核心：
 * 
 * 1. 通道（Channel）：负责连接
 * 		
 * 	   java.nio.channels.Channel 接口：
 * 			|--SelectableChannel
 * 				|--SocketChannel
 * 				|--ServerSocketChannel
 * 				|--DatagramChannel
 * 
 * 				|--Pipe.SinkChannel
 * 				|--Pipe.SourceChannel
 * 
 * 2. 缓冲区（Buffer）：负责数据的存取
 * 
 * 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况
 * 
 */
public class TestBlockingNIO {

	//客户端
	@Test
	public void client() throws IOException{
		//1. 获取通道
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
		
		FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
		
		//2. 分配指定大小的缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//3. 读取本地文件，并发送到服务端
		while(inChannel.read(buf) != -1){
			buf.flip();
			sChannel.write(buf);
			buf.clear();
		}
		
		//4. 关闭通道
		inChannel.close();
		sChannel.close();
	}
	
	//服务端
	@Test
	public void server() throws IOException{
		//1. 获取通道
		ServerSocketChannel ssChannel = ServerSocketChannel.open();
		
		FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
		
		//2. 绑定连接
		ssChannel.bind(new InetSocketAddress(9898));
		
		//3. 获取客户端连接的通道
		SocketChannel sChannel = ssChannel.accept();
		
		//4. 分配指定大小的缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//5. 接收客户端的数据，并保存到本地
		while(sChannel.read(buf) != -1){
			buf.flip();
			outChannel.write(buf);
			buf.clear();
		}
		
		//6. 关闭通道
		sChannel.close();
		outChannel.close();
		ssChannel.close();
		
	}
	
}

3.非阻塞IO

package com.dason.nio2;

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.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

/*
 * 一、使用 NIO 完成网络通信的三个核心：
 * 
 * 1. 通道（Channel）：负责连接
 * 		
 * 	   java.nio.channels.Channel 接口：
 * 			|--SelectableChannel
 * 				|--SocketChannel
 * 				|--ServerSocketChannel
 * 				|--DatagramChannel
 * 
 * 				|--Pipe.SinkChannel
 * 				|--Pipe.SourceChannel
 * 
 * 2. 缓冲区（Buffer）：负责数据的存取
 * 
 * 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况
 * 
 */
public class TestNonBlockingNIO {
	
	//客户端
	@Test
	public void client() throws IOException{
		//1. 获取通道
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
		
		//2. 切换非阻塞模式
		sChannel.configureBlocking(false);
		
		//3. 分配指定大小的缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//4. 发送数据给服务端
		Scanner scan = new Scanner(System.in);
		
		while(scan.hasNext()){
			String str = scan.next();
			buf.put((new Date().toString() + "\n" + str).getBytes());
			buf.flip();
			sChannel.write(buf);
			buf.clear();
		}
		
		//5. 关闭通道
		sChannel.close();
	}

	//服务端
	@Test
	public void server() throws IOException{
		//1. 获取通道
		ServerSocketChannel ssChannel = ServerSocketChannel.open();
		
		//2. 切换非阻塞模式
		ssChannel.configureBlocking(false);
		
		//3. 绑定连接
		ssChannel.bind(new InetSocketAddress(9898));
		
		//4. 获取选择器
		Selector selector = Selector.open();
		
		//5. 将通道注册到选择器上, 并且指定“监听接收事件”
		ssChannel.register(selector, SelectionKey.OP_ACCEPT);
		
		//6. 轮询式的获取选择器上已经“准备就绪”的事件
		while(selector.select() > 0){
			
			//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			
			while(it.hasNext()){
				//8. 获取准备“就绪”的是事件
				SelectionKey sk = it.next();
				
				//9. 判断具体是什么事件准备就绪
				if(sk.isAcceptable()){
					//10. 若“接收就绪”，获取客户端连接
					SocketChannel sChannel = ssChannel.accept();
					
					//11. 切换非阻塞模式
					sChannel.configureBlocking(false);
					
					//12. 将该通道注册到选择器上
					sChannel.register(selector, SelectionKey.OP_READ);
				}else if(sk.isReadable()){
					//13. 获取当前选择器上“读就绪”状态的通道
					SocketChannel sChannel = (SocketChannel) sk.channel();
					
					//14. 读取数据
					ByteBuffer buf = ByteBuffer.allocate(1024);
					
					int len = 0;
					while((len = sChannel.read(buf)) > 0 ){
						buf.flip();
						System.out.println(new String(buf.array(), 0, len));
						buf.clear();
					}
				}
				
				//15. 取消选择键 SelectionKey
				it.remove();
			}
		}
	}
}

package com.dason.nio2;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

public class TestNonBlockingNIO2 {
	
	@Test
	public void send() throws IOException{
		DatagramChannel dc = DatagramChannel.open();
		
		dc.configureBlocking(false);
		
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		Scanner scan = new Scanner(System.in);
		
		while(scan.hasNext()){
			String str = scan.next();
			buf.put((new Date().toString() + ":\n" + str).getBytes());
			buf.flip();
			dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
			buf.clear();
		}
		
		dc.close();
	}
	
	@Test
	public void receive() throws IOException{
		DatagramChannel dc = DatagramChannel.open();
		
		dc.configureBlocking(false);
		
		dc.bind(new InetSocketAddress(9898));
		
		Selector selector = Selector.open();
		
		dc.register(selector, SelectionKey.OP_READ);
		
		while(selector.select() > 0){
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			
			while(it.hasNext()){
				SelectionKey sk = it.next();
				
				if(sk.isReadable()){
					ByteBuffer buf = ByteBuffer.allocate(1024);
					
					dc.receive(buf);
					buf.flip();
					System.out.println(new String(buf.array(), 0, buf.limit()));
					buf.clear();
				}
			}
			
			it.remove();
		}
	}

}


Dason_yu
关注
专栏目录
Java阻塞IO与非阻塞IO - OPEN 开发经验库
11-03
Java阻塞IO与非阻塞IO - OPEN 开发经验库
Java IO概念（阻塞与非阻塞、同步与异步、BIO、NIO、AIO剖析）
weixin_44795847的博客
04-21 1967
Java IO概念（阻塞与非阻塞、同步与异步、BIO、NIO、AIO剖析）
Java中的NIO（非阻塞IO）
最新发布
编程小弟的博客
03-28 852
Selector是NIO编程的基础，它允许一个单独的线程来监视多个输入通道，你可以注册多个通道到一个选择器，然后使用一个单独的线程来“选择”已经就绪的通道（这些通道要么已经准备好读，要么已经准备好写）。Java为每一种类型的访问提供了特定的通道，如FileChannel用于文件的数据访问，DatagramChannel用于UDP的数据访问，SocketChannel用于TCP的数据访问，ServerSocketChannel用于监听TCP的连接请求。特别是在处理网络数据时，需要确保数据的完整性和保密性。
Java I/O模型解析：阻塞与非阻塞、NIO与NIO2
silenceallat的博客
03-19 777
本文深入探讨了Java I/O模型的四种类型：阻塞与非阻塞I/O、NIO与NIO2。阻塞I/O适用于简单场景，非阻塞I/O适合高并发处理。NIO通过通道和缓冲区提升I/O性能，NIO2进一步优化文件操作。选择合适的I/O模型能显著提高Java应用性能。
JAVA NIO知识点总结(5)——网络阻塞IO与非阻塞IO
weixin_33739523的博客
01-07 367
2019独角兽企业重金招聘Python工程师标准>>> ...
阻塞式IO和非阻塞式IO
Leaviathan的博客
03-27 7809
什么是阻塞式IO，什么是非阻塞式IO？区分他们有何用？ 使用java的阻塞式IO实现非阻塞式IO。 怎么使用c语言实现非阻塞式socket线程？
JAVA非阻塞NIO_IO2
11-13
本书介绍了 Java 平台上的高级输入／输出，具体点说，就是使用 Java 2 标准版（J2SE）软件 开发包（SDK）1.4 及以后版本进行的输入／输出。J2SE 1.4 版代号 Merlin，包含可观的 I/O 新特 性，对此我们将作详细论述。...
Java-NIO非阻塞服务器示例.docx
11-15
Java-NIO（New I/O）包是Java 1.4版本中引入的新IO处理机制，可以实现非阻塞式的IO操作。NIO包提供了Channel、Buffer、Selector等接口，用于实现高效的IO处理。 二、非阻塞服务器端模式 非阻塞服务器端模式是指...
Java-NIO与IO的区别和比较.doc
09-02
1. **非阻塞I/O**：传统的Java IO基于流，通常是阻塞的，意味着在进行读写操作时，如果数据未准备好，线程会被阻塞直到数据可用。而NIO的非阻塞模式允许读写操作在数据未准备好时不会阻塞，而是立即返回，从而提高了...
自己写的Java NIO 同步不阻塞IO操作
08-30
Java NIO（New Input/Output）是Java标准库提供的一种I/O模型，它与传统的 Blocking I/O（阻塞式I/O）有所不同。在传统的IO模型中，读写操作会阻塞线程，直到数据准备好或者写入完成。而NIO则引入了非阻塞模式，使得...
Java阻塞IO与非阻塞IO
yellowatumn的专栏
11-09 8113
阻塞式I/O：(传统的IO) 以网络应用为例，在传统IO方式（阻塞IO）中需要监听一个ServerSocket，接受请求的连接为其提供服务（服务通常包括了处理请求并发送响应）下图是服务器的生命周期图，其中标有粗黑线条的部分表明会发生I/O阻塞。 此方式在遇到多请求时，只能等待前面的请求完成后才能处理新的请求，所以通常在Java中处理阻塞I/O要用到线程（大量的线程）。代码如下
java 同步/异步IO和阻塞/非阻塞IO 关系和概念解析
u014631304的博客
08-29 4149
java io模型，及相关同步异步，阻塞非阻塞概念解析
7-文件IO-阻塞与非阻塞IO
进击的小学生
09-25 5939
1. 阻塞 IO 通常来说，从普通文件读数据，无论你是采用 fscanf，fgets 也好，read 也好，一定会在有限的时间内返回。但是如果你从设备，比如终端（标准输入设备）读数据，只要没有遇到换行符(‘\n’)，read 一定会“堵”在那而不返回。还有比如从网络读数据，如果网络一直没有数据到来，read 函数也会一直堵在那而不返回。 read 的这种行为，称之为 block，一旦发生 bl...
阻塞IO与非阻塞NIO
12-03 388
通常的，对一个文件描述符指定的文件或设备, 有两种工作方式: 阻塞 与非阻塞 。所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 程序就进入等待 状态, 直到有东西可读或者可写为止。而对于非阻塞状态, 如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待 。 一种常用做法是：每建立一个Socket连接时，同时创建一个新线程对该Socke
常见的IO模型
peterkang202的专栏
04-09 852
本文讨论的背景是Linux环境下的network IO。本文最重要的参考文献是Richard Stevens的“UNIX? Network Programming Volume 1, Third Edition: The Sockets Networking ”，6.2节“I/O Models ”，Stevens在这节中详细说明了各种IO的特点和区别，如果英文够好的话，推荐直接阅读。Stevens的
java nio 阻塞_Java-NIO（七）：阻塞IO与非阻塞IO
weixin_33603331的博客
02-21 255
阻塞IO传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。注意：在阻塞IO操作的过程中，用来提高程序的解决方案一般是使用多线...
Java中阻塞IO和非阻塞IO
马雨寒的博客
07-06 1455
一、阻塞IO模型 最传统的一种IO模型，即在读写数据过程中会发生阻塞现象。当用户线程发出IO请求之后，内核回去看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用户线程交出CPU。当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，用户线程才会接触block状态。典型的阻塞IO模型的列子为：data = socket.read() 如果数据没有就绪，就会一直阻塞在read方法。 二、非阻塞IO模型 当用户线程发起一个read操作后，并不需要等待，而是马上就得到一个结果。
同步～异步～阻塞～非阻塞
MatrixHero的专栏
03-14 955
原文地址：步 和 异 步" style="text-decoration:none; color:rgb(55,133,80)">同 步 和 异 步作者：zenos   一、同步～异步～阻塞～非阻塞     同步（Synchronous）和异步（Asynchronous）的概念本来来自通信领域：首先是通信的同步，主要是指客户端在发送请求后，必须得在服务端有回应后才发送下一个请
Java 非阻塞 IO 和异步 IO区别（详解）
孤刺
10-11 2378
上一篇文章介绍了 Java NIO 中 Buffer、Channel 和 Selector 的基本操作，主要是一些接口操作，比较简单。 本文将介绍非阻塞 IO 和异步 IO，也就是大家耳熟能详的 NIO 和 AIO。很多初学者可能分不清楚异步和非阻塞的区别，只是在各种场合能听到异步非阻塞这个词。 本文会先介绍并演示阻塞模式，然后引入非阻塞模式来对阻塞模式进行优化，最后再介绍 JDK7 引入的异步 IO，由于网上关于异步 IO 的介绍相对较少，所以这部分内容我会介绍得具体一些。 希望看完本文，读者可以对非阻塞
Java NIO非阻塞IO与并发多线程实战
"这篇文档是关于NIO在并发多线程环境下的开发指南，主要讨论了如何利用非阻塞I/O提高网络服务的可扩展性，并深入解析了Java NIO的非阻塞I/O API。文档作者是Doug Lea，一位在State University of New York at Oswego...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值