很多时候对于不同的IO模型的概念和原理我们可能不是很清楚,有时候可能也会在不同的IO间迷糊,笔者也是有同样的问题。所以经过系统的学习以后将我们常见的五种IO模型在这里做一下总结,以供大家参考和学习。
五种IO模型包括:阻塞IO、非阻塞IO、IO多路复用、信号驱动IO、异步IO。为了对后面的内容的一些西域不混淆,首先给大家介绍一下系统调用常用的几个函数和基本概念。
以下几个系统函数参考了一些书籍和文章,如果有不正确的地方还请大家指出。
函数名称 | 函数作用 |
---|---|
recvfrom | 提供给用户用于接收网络IO的系统接口,从套接字上接收一个消息,可同时应用于面向连接和无连接的套接字如果此系统调用返回值<0,并且 errno为EWOULDBLOCK或EAGAIN(套接字已标记为非阻塞,而接收操作被阻塞或者接收超时 )时,连接正常,阻塞接收数据(这很关键,前4种IO模型都设计此系统调用) |
select | 允许程序同时在多个底层文件描述符上,等待输入的到达或输出的完成。以数组形式存储文件描述符,64位机器默认2048个。当有数据准备好时,无法感知具体是哪个流OK了,所以需要一个一个的遍历,函数的时间复杂度为O(n) |
poll | 以链表形式存储文件描述符,没有长度限制。本质与select相同,函数的时间复杂度也为O(n) |
epoll | 基于事件驱动。如果某个流准备好了,会以事件通知,知道具体是哪个流,因此不需要遍历,函数的时间复杂度为O(1) |
sigaction | 用于设置对信号的处理方式,也可检验对某信号的预设处理方式。Linux使用SIGIO信号来实现IO异步通知机制 |
同步和异步是针对应用程序和内核交互而言的。
概念 | |
---|---|
同步 | 用户进程触发IO操作并等待或轮询的去查看是否就绪 |
异步 | 用户进程触发IO操作以后便开始做自己的事情,当IO操作已经完成的时候会得到IO完成的通知,需要CPU支持 |
阻塞和非阻塞是针对于进程在访问数据的时候。根据IO操作的就绪状态来采取的不同的方式。
概念 | |
---|---|
阻塞 | 阻塞方式下读取或写入方法将一直等待 |
非阻塞 | 非阻塞方式下读取或写入方法会立即返回一个状态值 |
学习过操作系统的伙伴应该知道,不管是网络IO还是磁盘IO,对于读操作而言,都是等到网络的某个数据分组到达后/数据准备好后,将数据拷贝到内核空间的缓冲区中,再从内核空间拷贝到用户空间的缓冲区。执行流程图大致如图:
通过流程图可以看到,阻塞IO的执行过程是进程进行系统调用,等待内核将数据准备好并复制到用户态缓冲区后,进程放弃使用CPU并一直阻塞在此,直到数据准备好。
每次应用程序询问内核是否有数据准备好。如果就绪,就进行拷贝操作;如果未就绪,就不阻塞程序,内核直接返回未就绪的返回值,等待用户程序下一个轮询。在每一次询问之前,对于程序来说是非阻塞的,占用CPU资源,可以做其他事情。执行流程图大致如图:
主要有两个阶段:
在这两个阶段中,用户进程只有在数据复制阶段被阻塞了,而等待数据阶段没有阻塞,但是用户进程需要盲等,不停地轮询内核,看数据是否准备好。
相比于阻塞IO模型,多路复用只是多了一个select/poll/epoll函数。select函数会不断地轮询自己所负责的文件描述符/套接字的到达状态,当某个套接字就绪时,就对这个套接字进行处理。select负责轮询等待,recvfrom负责拷贝。当用户进程调用该select,select会监听所有注册好的IO,如果所有IO都没注册好,调用进程就阻塞。多路复用一般都是用于网络IO,服务端与多个客户端的建立连接。执行流程图大致如图:
对于客户端来说,一般感受不到阻塞,因为请求来了,可以用放到线程池里执行;但对于执行select的操作系统而言,是阻塞的,需要阻塞地等待某个套接字变为可读。IO多路复用其实是阻塞在select,poll,epoll这类系统调用上的,复用的是执行select,poll,epoll的线程。
当数据报准备好的时候,内核会向应用程序发送一个信号,进程对信号进行捕捉,并且调用信号处理函数来获取数据报。执行流程图大致如图:
该模型也分为两个阶段:
用户进程发起系统调用后,立刻就可以开始去做其他的事情,然后直到I/O数据准备好并复制完成后,内核会给用户进程发送通知,告诉用户进程操作已经完成了。
异步I/O执行的两个阶段都不会阻塞读写操作,由内核完成,完成后内核将数据放到指定的缓冲区,通知应用程序来取。
操作系统的IO模型是底层基石,Java对于IO的操作其实就是进一步的封装。
BIO–同步阻塞,JDK1.4之前常用的编程方式,适用于连接数目比较小且固定的架构,对服务器资源要求高,并发局限于应用中。在使用的时候,首先在服务端启动一个ServerSocket来监听网络请求,客户端启动Socket发起网络请求,默认情况下ServerSocket会建立一个线程来处理此请求,如果服务端没有线程可用,客户端则会阻塞等待或遭到拒绝,并发效率比较低。
我们使用java来模拟IO模型的连接,首先编写服务端的代码:
/**
* @Author likangmin
* @create 2020/12/02 13:35
*/
public class Server {
public static void main(String[] args) {
int port=genPort(args);
ServerSocket server=null;
ExecutorService service= Executors.newFixedThreadPool(50);
try {
server=new ServerSocket(port);
System.out.println("server started!");
while (true){
Socket socket=server.accept();
service.execute(new Handler(socket));
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(server!=null){
try {
server.close();
} catch (IOException e) {
e.printStackTrace();
}
}
server=null;
}
}
private static int genPort(String[] args) {
if(args.length>0){
return Integer.parseInt(args[0]);
}else{
return 9999;
}
}
static class Handler implements Runnable{
Socket socket=null;
public Handler(Socket socket){
this.socket=socket;
}
@Override
public void run() {
BufferedReader reader=null;
PrintWriter writer=null;
try {
reader=new BufferedReader(new InputStreamReader(socket.getInputStream(),"UTF-8"));
writer=new PrintWriter(new OutputStreamWriter(socket.getOutputStream(),"UTF-8"));
String readMassage=null;
while (true){
System.out.println("server reading...");
if((readMassage=reader.readLine())==null){
break;
}
System.out.println(readMassage);
writer.println("server recive:"+readMassage);
writer.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(socket!=null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
socket=null;
if(reader!=null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
reader=null;
if(writer!=null){
writer.close();
}
writer=null;
}
}
}
}
编写一个客户端:
/**
* @Author likangmin
* @create 2020/12/02 13:35
*/
public class Client {
public static void main(String[] args) {
String host=null;
int port=0;
if(args.length>2){
host=args[0];
port=Integer.parseInt(args[1]);
}else{
host="127.0.0.1";
port=9999;
}
Socket socket=null;
BufferedReader reader = null;
PrintWriter writer = null;
Scanner s = new Scanner(System.in);
try{
socket = new Socket(host, port);
String message = null;
reader = new BufferedReader(
new InputStreamReader(socket.getInputStream(), "UTF-8"));
writer = new PrintWriter(
socket.getOutputStream(), true);
while(true){
message = s.nextLine();
if(message.equals("exit")){
break;
}
writer.println(message);
writer.flush();
System.out.println(reader.readLine());
}
}catch(Exception e){
e.printStackTrace();
}finally{
if(socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
socket = null;
if(reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
reader = null;
if(writer != null){
writer.close();
}
writer = null;
}
}
}
然后启动,先启动服务端,再启动客户端,然后输入数据
会发现服务端一直会阻塞在接收数据那里。
NIO–同步非阻塞,是基于事件驱动思想来完成的,适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,并发局限于应用中,编程复杂,JDK1.4 开始支持。当 socket 有流可读或可写入时,操作系统会相应地通知应用程序进行处理,应用再将流读取到缓冲区或写入操作系统。一个有效的请求对应一个线程,当连接没有数据时,是没有工作线程来处理的。
服务器实现模式为一个请求一个通道,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理。NIO中有几个比较重要的角色:缓冲区Buffer,通道Channel,多路复用器Selector。
(1)Buffer
在NIO库中,所有数据都是用缓冲区(用户空间缓冲区)处理的。在读取数据时,它是直接读到缓冲区中的;在写入数据时,也是写入到缓冲区中。任何时候访问NIO中的数据,都是通过缓冲区进行操作。
缓冲区实际上是一个数组,并提供了对数据的结构化访问以及维护读写位置等信息。
(2)Channel
nio中对数据的读取和写入要通过Channel,它就像水管一样,是一个通道。通道不同于流的地方就是通道是双向的,可以用于读、写和同时读写操作。
(3)Selector
多路复用器,用于注册通道。客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
这里我们同样写一个demo作为例子,来让大家知道怎么使用和使用NIO的步骤,为了让大家看的比较清楚,在适当的地方添加了注释。同样的先写服务端的代码:
/**
* @Author likangmin
* @create 2020/12/02 13:35
*/
public class NIOServer implements Runnable {
// 多路复用器, 选择器。 用于注册通道的。
private Selector selector;
// 定义了两个缓存。分别用于读和写。 初始化空间大小单位为字节。
private ByteBuffer readBuffer = ByteBuffer.allocate(1024);
private ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
public static void main(String[] args) {
new Thread(new NIOServer(9999)).start();
}
public NIOServer(int port) {
init(port);
}
private void init(int port){
try {
System.out.println("server starting at port " + port + " ...");
// 开启多路复用器
this.selector = Selector.open();
// 开启服务通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
// 非阻塞, 如果传递参数true,为阻塞模式。
serverChannel.configureBlocking(false);
// 绑定端口
serverChannel.bind(new InetSocketAddress(port));
// 注册,并标记当前服务通道状态
/*
* register(Selector, int)
* int - 状态编码
* OP_ACCEPT : 连接成功的标记位。
* OP_READ : 可以读取数据的标记
* OP_WRITE : 可以写入数据的标记
* OP_CONNECT : 连接建立后的标记
*/
serverChannel.register(this.selector, SelectionKey.OP_ACCEPT);
System.out.println("server started.");
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run(){
while(true){
try {
// 阻塞方法,当至少一个通道被选中,此方法返回。
// 通道是否选择,由注册到多路复用器中的通道标记决定。
this.selector.select();
// 返回以选中的通道标记集合, 集合中保存的是通道的标记。相当于是通道的ID。
Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
while(keys.hasNext()){
SelectionKey key = keys.next();
// 将本次要处理的通道从集合中删除,下次循环根据新的通道列表再次执行必要的业务逻辑
keys.remove();
// 通道是否有效
if(key.isValid()){
// 阻塞状态
try{
if(key.isAcceptable()){
accept(key);
}
}catch(CancelledKeyException cke){
// 断开连接。 出现异常。
key.cancel();
}
// 可读状态
try{
if(key.isReadable()){
read(key);
}
}catch(CancelledKeyException cke){
key.cancel();
}
// 可写状态
try{
if(key.isWritable()){
write(key);
}
}catch(CancelledKeyException cke){
key.cancel();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void write(SelectionKey key){
this.writeBuffer.clear();
SocketChannel channel = (SocketChannel)key.channel();
Scanner reader = new Scanner(System.in);
try {
System.out.print("put message for send to client > ");
String line = reader.nextLine();
// 将控制台输入的字符串写入Buffer中。 写入的数据是一个字节数组。
writeBuffer.put(line.getBytes("UTF-8"));
writeBuffer.flip();
channel.write(writeBuffer);
channel.register(this.selector, SelectionKey.OP_READ);
} catch (IOException e) {
e.printStackTrace();
}
}
private void read(SelectionKey key){
try {
// 清空读缓存。
this.readBuffer.clear();
// 获取通道
SocketChannel channel = (SocketChannel)key.channel();
// 将通道中的数据读取到缓存中。通道中的数据,就是客户端发送给服务器的数据。
int readLength = channel.read(readBuffer);
// 检查客户端是否写入数据。
if(readLength == -1){
// 关闭通道
key.channel().close();
// 关闭连接
key.cancel();
return;
}
/*
* flip, NIO中最复杂的操作就是Buffer的控制。
* Buffer中有一个游标。游标信息在操作后不会归零,如果直接访问Buffer的话,数据有不一致的可能。
* flip是重置游标的方法。NIO编程中,flip方法是常用方法。
*/
this.readBuffer.flip();
// 字节数组,保存具体数据的。 Buffer.remaining() -> 是获取Buffer中有效数据长度的方法。
byte[] datas = new byte[readBuffer.remaining()];
// 是将Buffer中的有效数据保存到字节数组中。
readBuffer.get(datas);
System.out.println("from " + channel.getRemoteAddress() + " client : " + new String(datas, "UTF-8"));
// 注册通道, 标记为写操作。
channel.register(this.selector, SelectionKey.OP_WRITE);
} catch (IOException e) {
e.printStackTrace();
try {
key.channel().close();
key.cancel();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
private void accept(SelectionKey key){
try {
// 此通道为init方法中注册到Selector上的ServerSocketChannel
ServerSocketChannel serverChannel = (ServerSocketChannel)key.channel();
// 阻塞方法,当客户端发起请求后返回。 此通道和客户端一一对应。
SocketChannel channel = serverChannel.accept();
channel.configureBlocking(false);
// 设置对应客户端的通道标记状态,此通道为读取数据使用的。
channel.register(this.selector, SelectionKey.OP_READ);
} catch (IOException e) {
e.printStackTrace();
}
}
}
然后再写客户端的代码:
/**
* @Author likangmin
* @create 2020/12/02 13:35
*/
public class NIOClient {
public static void main(String[] args) {
// 远程地址创建
InetSocketAddress remote = new InetSocketAddress("localhost", 9999);
SocketChannel channel = null;
// 定义缓存。
ByteBuffer buffer = ByteBuffer.allocate(1024);
try {
// 开启通道
channel = SocketChannel.open();
// 连接远程服务器。
channel.connect(remote);
Scanner reader = new Scanner(System.in);
while(true){
System.out.print("put message for send to server > ");
String line = reader.nextLine();
if(line.equals("exit")){
break;
}
// 将控制台输入的数据写入到缓存。
buffer.put(line.getBytes("UTF-8"));
// 重置缓存游标
buffer.flip();
// 将数据发送给服务器
channel.write(buffer);
// 清空缓存数据。
buffer.clear();
// 读取服务器返回的数据
int readLength = channel.read(buffer);
if(readLength == -1){
break;
}
// 重置缓存游标
buffer.flip();
byte[] datas = new byte[buffer.remaining()];
// 读取数据到字节数组。
buffer.get(datas);
System.out.println("from server : " + new String(datas, "UTF-8"));
// 清空缓存。
buffer.clear();
}
} catch (IOException e) {
e.printStackTrace();
} finally{
if(null != channel){
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
AIO–异步非阻塞,进行读写操作时,只须直接调用api的read或write方法即可。一个有效请求对应一个线程,客户端的IO请求都是OS先完成了再通知服务器应用去启动线程进行处理。这里就不做代码演示了,大家又需要可以自己去找一些代码查看,操作起来比较简单。
最后给大家做一下总结,从效率上来说,可以简单理解为阻塞IO<非阻塞IO<多路复用IO<信号驱动IO<异步IO。从同步和异步来说,只有异步IO模型是异步的,其他均为同步。