IO模型和协程

Posted danielyang11

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了IO模型和协程相关的知识,希望对你有一定的参考价值。

一、 IO模型

五种IO模型:

blocking IO :阻塞IO

nonblocking IO 非阻塞IO

IO multiplexing  IO多路复用

signal driven IO 信号驱动IO

asynchronous IO 异步IO

对于一个network IO,它会涉及到两个系统对象,一个是调用这个IO的process(or thread),另一个就是系统内核。当一个read/recv读数据的操作发生时,该操作会经历两个阶段:

1, 等待数据准备

2, 将数据从内核拷贝到进程中

补充:

1, 输入操作:read,readv,recv,recvfrom,recvmsg共5个函数,如果会阻塞状态,则会经历wait data和copy data两个阶段,如果设置为非阻塞则在wait不到data时抛出异常

2, 输出操作:write,writev,send,sendto,sendmsg共5个函数,在发送缓冲区满了会阻塞在原地,如果设置为非阻塞,则会抛出异常

3, 接收外来链接:accept,与输入操作类似

4, 发起外出链接:connect,与操作类似

 

二、阻塞IO

回顾同步/异步/阻塞/非阻塞:

同步:提交一个任务之后要等待这个任务执行完毕

异步:只管提交任务,不等待这个任务执行完毕就可以去做其他的事情

阻塞:recv,recvfrom,accept,线程阶段 运行状态>>>阻塞状态>>>就绪

非阻塞:没有阻塞状态

 

在一个线程的IO模型中,我们recv的地方阻塞,我们就开启多线程,但是不管你开启多少个线程,这个recv的时间是不是没有被规避掉,不管是多线程还是多进程都没有规避掉IO这个时间

 

实际上,除非特别指定,几乎所有的IO接口(包括socket接口)都是阻塞的。这给网络编程带来了一个很大的问题,如在调用recv(1024)的同时,线程将被阻塞,在此期间,线程将无法执行任何运算或响应任何的网络请求

一个简单的解决方案:

在服务端使用多线程(或多进程)。多线程(或多进程)的目的是让每个连接都拥有独立的线程(或进程),这样任何一个连接的阻塞都不会影响其他的连接。

该方案的问题是:

开启多线程或都线程的方式,在遇到要同时响应成百上千的连接请求,则无论多线程还是多进程都会占用严重的系统资源,降低系统对外界相应效率,而且线程与进程本身也更容易进入假死状态

改进方案:

很多程序员可能会考虑使用“线程池”或“进程池”。“线程池”旨在减少创建和销毁线程的频率,其维持一定合理数量的线程,并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池,尽量重用已有的连接、减少创建和关闭连接的频率。这两种技术都可以很好的降低系统开销,都被广泛应用很大型系统,如websphere、tomcat和各种数据库等

改进后方案其实也存在着问题:

“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用IO接口带来的资源占用。而且,所谓“池”始终有其上限,当请求大大超过上限时,“池”构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池”必须其面临的响应规模,并根据规模调整“池”的大小

 

三、非阻塞IO

缺点:

1, 循环调用recv()将大幅推高cpu占用率,这也是我们在代码中留一句time.sleep(2)的原因,否则在低配主机下极容易出现卡机情况

2, 任务完成的响应延迟增大了,因为每过一段时间才去轮询一次read一次,而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低。

技术分享图片
import time
import socket

server = socket.socket()

ip_port = (127.0.0.1,8001)
server.bind(ip_port)

server.listen()
server.setblocking(False)
conn_list = []

while 1:
    while 1:
        try:
            conn,addr = server.accept()
            conn_list.append(conn)
            break
        except BlockingIOError:
            time.sleep(0.1)
            print(此时还没有人链接我)

    for sock in conn_list:
        print(sock)
        while 1:
            try:
                from_client_msg = sock.recv(1024)
                print(from_client_msg.decode(utf-8))
                sock.send(bhello)
                break
            except BlockingIOError:
                print(还没有任何的消息啊)
非阻塞iO模型服务端

 

技术分享图片
import socket
client = socket.socket()

client.connect((127.0.0.1,8001))
while 1:
    to_server_msg = input(我想对你说>>>>)
    client.send(to_server_msg.encode(utf-8))
    from_server_msg = client.recv(1024)
    print(from_server_msg.decode(utf-8))
非阻塞IO模型客户端

四、多路复用IO

结论:select的优势在于可以处理多个连接,不适用于单个连接

IO多路复用的机制:

Select:windows 、linux

Poll机制:linux和select监听机制一样,但是对监听列表里面的数量没有限制,select默认限制是1024个,但是他们两个都是操作系统轮询每一个被监听的文件描述符(如果数量很大,其实效率不太好),卡是否有可读操作

Epoll:linux它的监听机制和上面两个不同,他给每一个监听的对象绑定了一个回调函数,你这个对象有消息,那么触发回调函数给用户,用户就进行系统调用来拷贝数据,并不是轮询监听所有的被监听对象,这样的效率高很多。

 

技术分享图片
import select
import socket

server = socket.socket()
server.bind((127.0.0.1,8001))
rlist = [server,]
server.listen()
while 1:
    print(11111)
    rl,wl,el = select.select(rlist,[],[])#创建rl对象,监听
    print(222222)
    print(server对象>>>,server)
    print(rl)   #rl对象其实跟server对象(内容)一致
    for sock in rl: #当rl有值的时候,循环列表
        if sock == server: #值与server相同
            conn,addr = sock.accept() #建立连接
            rlist.append(conn) #把管道信息加入列表
        else:
            from_client_msg = sock.recv(1024)#conn
            print(from_client_msg.decode(utf-8)) #打印接收
IO多路复用服务端

 

技术分享图片
import socket

client = socket.socket()
client.connect((127.0.0.1,8001))

to_server_msg = input(发给服务端的消息:)
client.send(to_server_msg.encode(utf-8))
# from_server_msg = client.recv(1024)
# print(from_server_msg.decode(‘utf-8‘))
io多路复用客户端

 

五、异步IO

 

from gevent import monkey;monkey.patch_all()
import time
import gevent

def func1(n):
    print(xxxxxx,n)
    # gevent.sleep(2)
    time.sleep(2)
    print(cccccc,n)

def func2(m):
    print(111111,m)
    # gevent.sleep(2)
    time.sleep(2)
    print(222222,m)

start_time = time.time()
g1 = gevent.spawn(func1,alex)
g2 = gevent.spawn(func2,德玛西亚)
# g1.join() #
# g2.join()
gevent.joinall([g1,g2])
end_time = time.time()
print(end_time - start_time)

print(代码结束)

 

以上是关于IO模型和协程的主要内容,如果未能解决你的问题,请参考以下文章

异步IO和协程

异步io和协程

一种在 python 中用 asyncio 和协程实现的IO并发

python线程进程和协程

python之线程进程和协程

进程线程和协程的理解-自己随笔