菜单

Linux 下的五种 IO 模型

2020年3月13日 - 计算机服务器
Linux 下的五种 IO 模型

概念说明

用户空间与内核空间

现在操作系统都是采用虚拟存储器,那么对32位操作系统而言,它的寻址空间(虚拟存储空间)为4G(2的32次方)。操作系统的核心是内核,独立于普通的应用程序,可以访问受保护的内存空间,也有访问底层硬件设备的所有权限。为了保证用户进程不能直接操作内核(kernel),保证内核的安全,操作系统将虚拟空间划分为两部分,一部分为内核空间,一部分为用户空间。针对linux操作系统而言,将最高的1G字节(从虚拟地址0xC0000000到0xFFFFFFFF),供内核使用,称为内核空间,而将较低的3G字节(从虚拟地址0×00000000到0xBFFFFFFF),供各个进程使用,称为用户空间。

进程切换

为了控制进程的执行,内核必须有能力挂起正在CPU上运行的进程,并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。因此可以说,任何进程都是在操作系统内核的支持下运行的,是与内核紧密相关的。

从一个进程的运行转到另一个进程上运行,这个过程中经过下面这些变化:

进程的阻塞

正在执行的进程,由于期待的某些事件未发生,如请求系统资源失败、等待某种操作的完成、新数据尚未到达或无新工作做等,则由系统自动执行阻塞原语(Block),使自己由运行状态变为阻塞状态。可见,进程的阻塞是进程自身的一种主动行为,也因此只有处于运行态的进程(获得CPU),才可能将其转为阻塞状态。当进程进入阻塞状态,是不占用CPU资源的。

文件描述符

文件描述符(File
descriptor)是计算机科学中的一个术语,是一个用于表述指向文件的引用的抽象化概念。

文件描述符在形式上是一个非负整数。实际上,它是一个索引值,指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时,内核向进程返回一个文件描述符。在程序设计中,一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。

缓存 IO

缓存 IO 又被称作标准 IO,大多数文件系统的默认 IO 操作都是缓存 IO。在
Linux 的缓存 IO 机制中,操作系统会将 IO 的数据缓存在文件系统的页缓存(
page cache
)中,也就是说,数据会先被拷贝到操作系统内核的缓冲区中,然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。

缓存 IO 的缺点:

数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作,这些数据拷贝操作所带来的
CPU 以及内存开销是非常大的。

Linux 下的五种 IO 模型。 

同步与异步 & 阻塞与非阻塞

在进行网络编程时,我们常常见到同步(Sync)/异步(Async),阻塞(Block)/非阻塞(Unblock)四种调用方式,先理解一些概念性的东西。

1.同步与异步

同步与异步同步和异步关注的是消息通信机制 (synchronous communication/
asynchronous
communication)所谓同步,就是在发出一个调用时,在没有得到结果之前,该调用就不返回。但是一旦调用返回,就得到返回值了。换句话说,就是由调用者主动等待这个调用的结果。

而异步则是相反,调用在发出之后,这个调用就直接返回了,所以没有返回结果。换句话说,当一个异步过程调用发出后,调用者不会立刻得到结果。而是在调用发出后,被调用者通过状态、通知来通知调用者,或通过回调函数处理这个调用。

典型的异步编程模型比如Node.js。

2016.4.17更新:

POSIX对这两个术语的定义:

2. 阻塞与非阻塞

阻塞和非阻塞关注的是程序在等待调用结果(消息,返回值)时的状态。

阻塞调用是指调用结果返回之前,当前线程会被挂起。调用线程只有在得到结果之后才会返回。非阻塞调用指在不能立刻得到结果之前,该调用不会阻塞当前线程。

IO模型的分类

关于阻塞/非阻塞 & 同步/异步更加形象的比喻

老张爱喝茶,废话不说,煮开水。
出场人物:老张,水壶两把(普通水壶,简称水壶;会响的水壶,简称响水壶)。

  1. 老张把水壶放到火上,立等水开。(同步阻塞) 老张觉得自己有点傻

2.
老张把水壶放到火上,去客厅看电视,时不时去厨房看看水开没有。(同步非阻塞) 老张还是觉得自己有点傻,于是变高端了,买了把会响笛的那种水壶。水开之后,能大声发出嘀~~~~的噪音。

  1. 老张把响水壶放到火上,立等水开。(异步阻塞) 老张觉得这样傻等意义不大

4.
老张把响水壶放到火上,去客厅看电视,水壶响之前不再去看它了,响了再去拿壶。(异步非阻塞) 老张觉得自己聪明了。

所谓同步异步,只是对于水壶而言。普通水壶,同步;响水壶,异步。虽然都能干活,但响水壶可以在自己完工之后,提示老张水开了。这是普通水壶所不能及的。同步只能让调用者去轮询自己(情况2中),造成老张效率的低下。

所谓阻塞非阻塞,仅仅对于老张而言。立等的老张,阻塞;看视的老张,非阻塞。情况1和情况3中老张就是阻塞的,媳妇喊他都不知道。虽然3中响水壶是异步的,可对于立等的老张没有太大的意义。所以一般异步是配合非阻塞使用的,这样才能发挥异步的效用。

 blocking IO:阻塞IO

Linux下的五种IO模型

前四种都是同步,只有最后一种才是异步IO。

 nonblocking IO:非阻塞IO

阻塞IO模型

在这个模型中,应用程序(application)为了执行这个read操作,会调用相应的一个system
call,将系统控制权交给kernel,然后就进行等待(这其实就是被阻塞了)。kernel开始执行这个system
call,执行完毕后会向应用程序返回响应,应用程序得到响应后,就不再阻塞,并进行后面的工作。

 IO multiplexing:IO多路复用

非阻塞IO

在linux下,应用程序可以通过设置文件描述符的属性O_Linux 下的五种 IO 模型。NONBLOCK,IO操作可以立即返回,但是并不保证IO操作成功。也就是说,当应用程序设置了O_NONBLOCK之后,执行write操作,调用相应的system
call,这个system
call会从内核中立即返回。但是在这个返回的时间点,数据可能还没有被真正的写入到指定的地方。也就是说,kernel只是很快的返回了这个
system
call(只有立马返回,应用程序才不会被这个IO操作blocking),但是这个system
call具体要执行的事情(写数据)可能并没有完成。而对于应用程序,虽然这个IO操作很快就返回了,但是它并不知道这个IO操作是否真的成功了,为了知道IO操作是否成功,一般有两种策略:一是需要应用程序主动地循环地去问kernel(这种方法就是同步非阻塞IO);二是采用IO通知机制,比如:IO多路复用(这种方法属于异步阻塞IO)或信号驱动IO(这种方法属于异步非阻塞IO)。

 signal driven IO:异步IO

IO多路复用(异步阻塞IO)

和之前一样,应用程序要执行read操作,因此调用一个system call,这个system
call被传递给了kernel。但在应用程序这边,它调用system
call之后,并不等待kernel的返回结果而是立即返回,虽然立即返回的调用函数是一个异步的方式,但应用程序会被像select()、poll和epoll等具有复用多个文件描述符的函数阻塞住,一直等到这个system
call有结果返回了,再通知应用程序。也就是说,“在这种模型中,IO函数是非阻塞的,使用阻塞
select、poll、epoll系统调用来确定一个 或多个IO
描述符何时能操作。”所以,从IO操作的实际效果来看,异步阻塞IO和第一种同步阻塞IO是一样的,应用程序都是一直等到IO操作成功之后(数据已经被写入或者读取),才开始进行下面的工作。不同点在于异步阻塞IO用一个select函数可以为多个描述符提供通知,提高了并发性。举个例子:假如有一万个并发的read请求,但是网络上仍然没有数据,此时这一万个read会同时各自阻塞,现在用select、poll、epoll这样的函数来专门负责阻塞同时监听这一万个请求的状态,一旦有数据到达了就负责通知,这样就将之前一万个的各自为战的等待与阻塞转为一个专门的函数来负责与管理。与此同时,异步阻塞IO和第二种同步非阻塞IO的区别在于:同步非阻塞IO是需要应用程序主动地循环去询问是否有操作数据可操作,而异步阻塞IO是通过像select和poll等这样的IO多路复用函数来同时检测多个事件句柄来告知应用程序是否可以有数据操作。

一 socket里面的阻塞

信号驱动IO (signal driven IO (SIGIO))

应用程序提交read请求的system
call,然后,kernel开始处理相应的IO操作,而同时,应用程序并不等kernel返回响应,就会开始执行其他的处理操作(应用程序没有被IO操作所阻塞)。当kernel执行完毕,返回read的响应,就会产生一个信号或执行一个基于线程的回调函数来完成这次
IO 处理过程。

从理论上说,阻塞IO、IO复用和信号驱动的IO都是同步IO模型。因为在这三种模型中,IO的读写操作都是在IO事件发生之后由应用程序来完成。而POSIX规范所定义的异步IO模型则不同。对异步IO而言,用户可以直接对IO执行读写操作,这些操作告诉内核用户读写缓冲区的位置,以及IO操作完成后内核通知应用程序的方式。异步IO读写操作总是立即返回,而不论IO是否阻塞的,因为真主的读写操作已经由内核接管。也就是说,同步IO模型要求用户代码自行执行IO操作(将数据从内核缓冲区读入用户缓冲区,或将数据从用户缓冲区写入内核缓冲区),而异步IO机制则是由内核来执行IO操作(数据在内核缓冲区和用户缓冲区之间的移动是由内核在后台完成的)。你可以这样认为,同步IO向应用程序通知的是IO就绪事件,而异步IO向应用程序通知的是IO完成事件。linux环境下,aio.h头文件中定义的函数提供了对异步IO的支持。

 在socket的server端是有三个阻塞的。

异步IO (asynchronous IO (the POSIX aio_functions))

异步IO与上面的异步概念是一样的,
当一个异步过程调用发出后,调用者不能立刻得到结果,实际处理这个调用的函数在完成后,通过状态、通知和回调来通知调用者的输入输出操作。异步IO的工作机制是:告知内核启动某个操作,并让内核在整个操作完成后通知我们,这种模型与信号驱动的IO区别在于,信号驱动IO是由内核通知我们何时可以启动一个IO操作,这个IO操作由用户自定义的信号函数来实现,而异步IO模型是由内核告知我们IO操作何时完成。为了实现异步IO,专门定义了一套以aio开头的API,如:aio_read.

小结:前四种模型–阻塞IO、非阻塞IO、多路复用IO和信号驱动IO都属于同步模式,因为其中真正的IO操作(函数)都将会阻塞进程,只有异步IO模型真正实现了IO操作的异步性。

 前两个阻塞的原因是:接收数据和连接,recv接收数据和accept建立连接的时候是有IO阻塞的,分为两步,1是:等待数据的准备,也就是从客户端发送连接,但是需要通过网卡发送到服务端的操作系统的内存空间,这一步是耗时时间比较长的;2是:操作系统拿到数据后还需要拷贝到程序的内存空间的。

IO复用

为了解释这个名词,首先来理解下复用这个概念,复用也就是共用的意思,这样理解还是有些抽象,为此,咱们来理解下复用在通信领域的使用,在通信领域中为了充分利用网络连接的物理介质,往往在同一条网络链路上采用时分复用或频分复用的技术使其在同一链路上传输多路信号,到这里我们就基本上理解了复用的含义,即公用某个“介质”来尽可能多的做同一类(性质)的事,那IO复用的“介质”是什么呢?为此我们首先来看看服务器编程的模型,客户端发来的请求服务端会产生一个进程来对其进行服务,每当来一个客户请求就产生一个进程来服务,然而进程不可能无限制的产生,因此为了解决大量客户端访问的问题,引入了IO复用技术,即:一个进程可以同时对多个客户请求进行服务。也就是说IO复用的“介质”是进程(准确的说复用的是select和poll,因为进程也是靠调用select和poll来实现的),复用一个进程(select和poll)来对多个IO进行服务,虽然客户端发来的IO是并发的但是IO所需的读写数据多数情况下是没有准备好的,因此就可以利用一个函数(select和poll)来监听IO所需的这些数据的状态,一旦IO有数据可以进行读写了,进程就来对这样的IO进行服务。

理解完IO复用后,我们在来看下实现IO复用中的三个API(select、poll和epoll)的区别和联系,select,poll,epoll都是IO多路复用的机制,IO多路复用就是通过一种机制,可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知应用程序进行相应的读写操作。但select,poll,epoll本质上都是同步IO,因为他们都需要在读写事件就绪后自己负责进行读写,也就是说这个读写过程是阻塞的,而异步IO则无需自己负责进行读写,异步IO的实现会负责把数据从内核拷贝到用户空间。三者的原型如下所示:

  因为IO模型的区别就是在两个阶段上各有不同的情况。

select

select的第一个参数nfds为fdset集合中最大描述符值加1,fdset是一个位数组,其大小限制为__FD_SETSIZE(1024),位数组的每一位代表其对应的描述符是否需要被检查。第二三四参数表示需要关注读、写、错误事件的文件描述符位数组,这些参数既是输入参数也是输出参数,可能会被内核修改用于标示哪些描述符上发生了关注的事件,所以每次调用select前都需要重新初始化fdset。timeout参数为超时时间,该结构会被内核修改,其值为超时剩余的时间。

select的调用步骤如下:

总结下select的几大缺点:

(1)每次调用select,都需要把fd集合从用户态拷贝到内核态,这个开销在fd很多时会很大
(2)同时每次调用select都需要在内核遍历传递进来的所有fd,这个开销在fd很多时也很大
(3)select支持的文件描述符数量太小了,默认是1024

 后面那一个send:操作也有两步:1,将数据从程序的课程中拷贝到操作系统的内存空间;2再将数据通过网卡传输到客户端,这一步还是有网络延迟的,但是与服务端的IO没有关系,也就是说send发送是的IO是比较小的。因为send发送数据是只有将数据拷贝到操作系统的内存空间就不管了,因此send的IO时间是比较短的。

poll

poll与select不同,通过一个pollfd数组向内核传递需要关注的事件,故没有描述符个数的限制,pollfd中的events字段和revents分别用于标示关注的事件和发生的事件,故pollfd数组只需要被初始化一次。

poll的实现机制与select类似,其对应内核中的sys_poll,只不过poll向内核传递pollfd数组,然后对pollfd中的每个描述符进行poll,相比处理fdset来说,poll效率更高。poll返回后,需要对pollfd中的每个元素检查其revents值,来得指事件是否发生。

二 阻塞IO(blocking IO)

epoll

直到Linux2.6才出现了由内核直接支持的实现方法,那就是epoll,被公认为Linux2.6下性能最好的多路IO就绪通知方法。epoll可以同时支持水平触发和边缘触发(Edge
Triggered,只告诉进程哪些文件描述符刚刚变为就绪状态,它只说一遍,如果我们没有采取行动,那么它将不会再次告知,这种方式称为边缘触发),理论上边缘触发的性能要更高一些,但是代码实现相当复杂。epoll同样只告知那些就绪的文件描述符,而且当我们调用epoll_wait()获得就绪文件描述符时,返回的不是实际的描述符,而是一个代表就绪描述符数量的值,你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可,这里也使用了内存映射(mmap)技术,这样便彻底省掉了这些文件描述符在系统调用时复制的开销。另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中,进程只有在调用一定的方法后,内核才对所有监视的文件描述符进行扫描,而epoll事先通过epoll_ctl()来注册一个文件描述符,一旦基于某个文件描述符就绪时,内核会采用类似callback的回调机制,迅速激活这个文件描述符,当进程调用epoll_wait()时便得到通知。

epoll既然是对select和poll的改进,就应该能避免上述的三个缺点。那epoll都是怎么解决的呢?在此之前,我们先看一下epoll
和select和poll的调用接口上的不同,select和poll都只提供了一个函数——select或者poll函数。而epoll提供了三个函
数,epoll_create,epoll_ctl和epoll_wait,epoll_create是创建一个epoll句柄;epoll_ctl是注
册要监听的事件类型;epoll_wait则是等待事件的产生。

对于第一个缺点,epoll的解决方案在epoll_ctl函数中。每次注册新的事件到epoll句柄中时(在epoll_ctl中指定
EPOLL_CTL_ADD),会把所有的fd拷贝进内核,而不是在epoll_wait的时候重复拷贝。epoll保证了每个fd在整个过程中只会拷贝一次。

对于第二个缺点,epoll的解决方案不像select或poll一样每次都把current轮流加入fd对应的设备等待队列中,而只在
epoll_ctl时把current挂一遍(这一遍必不可少)并为每个fd指定一个回调函数,当设备就绪,唤醒等待队列上的等待者时,就会调用这个回调
函数,而这个回调函数会把就绪的fd加入一个就绪链表)。epoll_wait的工作实际上就是在这个就绪链表中查看有没有就绪的fd(利用
schedule_timeout()实现睡一会,判断一会的效果,和select实现中的第7步是类似的)。

对于第三个缺点,epoll没有这个限制,它所支持的FD上限是最大可以打开文件的数目,这个数字一般远大于2048,举个例子,
在1GB内存的机器上大约是10万左右,具体数目可以cat
/proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。

  时间上的等待就是阻塞IO。而多进程,多线程和协程都没有完全的解决IO。

总结

(1)select,poll实现需要自己不断轮询所有fd集合,直到设备就绪,期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用
epoll_wait不断轮询就绪链表,期间也可能多次睡眠和唤醒交替,但是它是设备就绪时,调用回调函数,把就绪fd放入就绪链表中,并唤醒在
epoll_wait中进入睡眠的进程。虽然都要睡眠和交替,但是select和poll在“醒着”的时候要遍历整个fd集合,而epoll在“醒着”的
时候只要判断一下就绪链表是否为空就行了,这节省了大量的CPU时间,这就是回调机制带来的性能提升。

(2)select,poll每次调用都要把fd集合从用户态往内核态拷贝一次,并且要把current往设备等待队列中挂一次,而epoll只要
一次拷贝,而且把current往等待队列上挂也只挂一次(在epoll_wait的开始,注意这里的等待队列并不是设备等待队列,只是一个epoll内
部定义的等待队列),这也能节省不少的开销。

如下:

图片 1

三 非阻塞IO(nonblocking IO)

 为了降低IO的阻塞,如果遇到了IO,就会切换到另一个任务去执行。但是这样占用cpu过高

  socket.setblocking:设置阻塞IO和非阻塞IO。需要传入一个参数,这个参数默认为True,也就是阻塞。如果将这个参数改成False,就可以成为非阻塞。但是不推荐用。这个的功能就是响应延迟增大,可以自己检测IO。

  BlockingIOError:就是IO异常。

服务端:

from socket import *
import time
s=socket(AF_INET,SOCK_STREAM)
s.bind(('127.0.0.1',8083))
s.listen(5)
s.setblocking(False)
conn_l=[]
while True:
    try:
        conn,addr=s.accept()
        print('%s:%s' %(addr[0],addr[1]))
        conn_l.append(conn)
    except BlockingIOError:
        del_l=[]
        print('没有数据来')
        #基于建立好的连接收发消息
        print(len(conn_l))
        for conn in conn_l:
            try:
                data=conn.recv(1024)
                if not data:
                    del_l.append(conn)
                    continue
                conn.send(data.upper())
            except BlockingIOError:
                pass
            except ConnectionResetError:
                conn.close()
                del_l.append(conn)

        for conn in del_l:
            conn_l.remove(conn)

客户端 :

from socket import *

c=socket(AF_INET,SOCK_STREAM)
c.connect(('127.0.0.1',8083))

while True:
    msg=input('>>: ').strip()
    if not msg:continue
    c.send(msg.encode('utf-8'))
    data=c.recv(1024)
    print(data.decode('utf-8'))

四 IO多路复用(IO multiplexing)

 就是使用select模块检测行为;同时检测多个套接字的IO阻塞。

  select模型:就是循环的询问,也就是遇到IO循环的切换执行。但是在单个套接字时,遇到IO还是需要等待的。检测到的只有准备数据的时间的IO

  poll模型:和select模型差不多,主要是增加了检测的数目

  epoll模型:等待响应。谁好了,就给一个响应,然后在去执行,不过windows系统不支持。

IO多路复用都是基于多个套接字的使用。如果在单套接字下,IO多路复用的效率比阻塞IO还要低。

 select模块

  select.select:

  select方法里的timeout:等待时间

    rlist:读到列表里面的数据,列表里面放的是需要检测的套接字。

    wlist:写到列表里面的数据。如果没有数据可以传入一个空的列表

    xlist:如果没有数据剋有传入一个空的列表

  select返回的结果是一个元组的格式,元组里面有三个列表。

服务端:

from socket import *
import select
import time
s=socket(AF_INET,SOCK_STREAM)
s.bind(('127.0.0.1',8085))
s.listen(5)
s.setblocking(False)
read_list=[s,]
while True:
    print('检测的套接字数%s' %len(read_list))
    r_l,_,_=select.select(read_list,[],[])
    # print('准备好数据的套接字数%s' %len(r_l))
    for obj in r_l:
        if obj == s:
            conn,addr=obj.accept()
            read_list.append(conn)
            print('客户端ip:%s,端口:%s' %(addr[0],addr[1]))
        else:
            try:
                data=obj.recv(1024)
                if not data:
                    obj.close()
                    read_list.remove(obj)
                    continue
                obj.send(data.upper())
            except ConnectionResetError:
                obj.close()
                read_list.remove(obj)

 客户端:

from socket import *

c=socket(AF_INET,SOCK_STREAM)
c.connect(('127.0.0.1',8085))

while True:
    msg=input('>>: ').strip()
    if not msg:continue
    c.send(msg.encode('utf-8'))
    data=c.recv(1024)
    print(data.decode('utf-8'))

一般的情况下用_来接收没有用的内容。

五 异步IO

应用程序不用等待,只是让操作系统有了结果响应一下,然后应用程序在从操作系统中拷贝数据。

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图