python(十)下：事件驱动与 阻塞IO、非阻塞IO、IO多路复用、异步IO

最新推荐文章于 2021-06-19 23:27:37 发布
最新推荐文章于 2021-06-19 23:27:37 发布
阅读量797 收藏 2
点赞数
原文链接：https://blog.csdn.net/fgf00/article/details/52793739
版权

上节的问题：
协程：遇到IO操作就切换。
但什么时候切回去呢？怎么确定IO操作完了？

一、事件驱动模型介绍

通常，我们写服务器处理模型的程序时，有以下几种模型：

（1）每收到一个请求，创建一个新的进程，来处理该请求；
（2）每收到一个请求，创建一个新的线程，来处理该请求；
（3）每收到一个请求，放入一个事件列表，让主进程通过非阻塞I/O方式来处理请求

第三种就是协程、事件驱动的方式，一般普遍认为第（3）种方式是大多数网络服务器采用的方式
　
论事件驱动模型
在UI编程中，，常常要对鼠标点击进行相应，首先如何获得鼠标点击呢？
方式一：创建一个线程，该线程一直循环检测是否有鼠标点击，那么这个方式有以下几个缺点：

  1. CPU资源浪费，可能鼠标点击的频率非常小，但是扫描线程还是会一直循环检测，这会造成很多的CPU资源浪费；如果扫描鼠标点击的接口是阻塞的呢？
  2. 如果是堵塞的，又会出现下面这样的问题，如果我们不但要扫描鼠标点击，还要扫描键盘是否按下，由于扫描鼠标时被堵塞了，那么可能永远不会去扫描键盘；
  3. 如果一个循环需要扫描的设备非常多，这又会引来响应时间的问题；
    所以，该方式是非常不好的。

方式二：就是事件驱动模型
目前大部分的UI编程都是事件驱动模型，如很多UI平台都会提供onClick()事件，这个事件就代表鼠标按下事件。事件驱动模型大体思路如下：

  1. 有一个事件（消息）队列；
  2. 鼠标按下时，往这个队列中增加一个点击事件（消息）；
  3. 有个循环，不断从队列取出事件，根据不同的事件，调用不同的函数，如onClick()、onKeyDown()等；
  4. 事件（消息）一般都各自保存各自的处理函数指针，这样，每个消息都有独立的处理函数；
    这里写图片描述
    事件驱动编程是一种编程范式，这里程序的执行流由外部事件来决定。它的特点是包含一个事件循环，当外部事件发生时使用回调机制来触发相应的处理。另外两种常见的编程范式是（单线程）同步以及多线程编程。
    　
    让我们用例子来比较和对比一下单线程、多线程以及事件驱动编程模型。下图展示了随着时间的推移，这三种模式下程序所做的工作。这个程序有3个任务需要完成，每个任务都在等待I/O操作时阻塞自身。阻塞在I/O操作上所花费的时间已经用灰色框标示出来了。
    这里写图片描述

最初的问题：怎么确定IO操作完了切回去呢？通过回调函数

二、Select\Poll\Epoll异步IOIO => 多路复用

前面是用协程实现的IO阻塞自动切换，那么协程又是怎么实现的，在原理是是怎么实现的。如何去实现事件驱动的情况下IO的自动阻塞的切换，这个学名叫什么呢？ => IO多路复用
比如socketserver，多个客户端连接，单线程下实现并发效果，就叫多路复用。
　
同步IO和异步IO，阻塞IO和非阻塞IO分别是什么，到底有什么区别？不同的人在不同的上下文下给出的答案是不同的。所以先限定一下本文的上下文。

本文讨论的背景是Linux环境下的network IO。

1、阻塞IO, 非阻塞IO, 同步IO,异步IO 介绍

在进行解释之前，首先要说明几个概念：

  • 用户空间和内核空间
  • 进程切换
  • 进程的阻塞
  • 文件描述符
  • 缓存 I/O

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

  • 进程切换
    为了控制进程的执行，内核必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。因此可以说，任何进程都是在操作系统内核的支持下运行的，是与内核紧密相关的。
    　
    从一个进程的运行转到另一个进程上运行，这个过程中经过下面这些变化：

  1. 保存处理机上下文，包括程序计数器和其他寄存器。
  2. 更新PCB信息。
  3. 把进程的PCB移入相应的队列，如就绪、在某事件阻塞等队列。
  4. 选择另一个进程执行，并更新其PCB。
  5. 更新内存管理的数据结构。
  6. 恢复处理机上下文。
    注：总而言之就是很耗资源

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

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

  • 缓存 I/O
    缓存 I/O 又被称作标准 I/O，大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中，操作系统会将 I/O 的数据缓存在文件系统的页缓存（ page cache ）中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。用户空间没法直接访问内核空间的，内核态到用户态的数据拷贝
    　
    缓存 I/O 的缺点：
    数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作，这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。

  • 2、IO模式

    刚才说了，对于一次IO访问（以read举例），数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。所以说，当一个read操作发生时，它会经历两个阶段：

    1. 等待数据准备 (Waiting for the data to be ready)
    2. 将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)

    正式因为这两个阶段，linux系统产生了下面五种网络模式的方案。

    • 阻塞 I/O（blocking IO）
    • 非阻塞 I/O（nonblocking IO）
    • I/O 多路复用（ IO multiplexing）
    • 信号驱动 I/O（ signal driven IO）
    • 异步 I/O（asynchronous IO）

    注：由于signal driven IO在实际中并不常用，所以我这只提及剩下的四种IO Model。

    1）阻塞 I/O（blocking IO）

    在linux中，默认情况下所有的socket都是blocking，一个典型的读操作流程大概是这样：
    这里写图片描述
    当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据（对于网络IO来说，很多时候数据在一开始还没有到达。比如，还没有收到一个完整的UDP包。这个时候kernel就要等待足够的数据到来）。这个过程需要等待，也就是说数据被拷贝到操作系统内核的缓冲区中是需要一个过程的。而在用户进程这边，整个进程会被阻塞（当然，是进程自己选择的阻塞）。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。

    所以，阻塞 IO的特点就是在IO执行的两个阶段都被阻塞了。

    2）非阻塞 I/O（nonblocking IO）

    linux下，可以通过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操作时，流程是这个样子：
    这里写图片描述
    当用户进程发出read操作时，如果kernel中的数据还没有准备好，那么它并不会block用户进程，而是立刻返回一个error。从用户进程角度讲 ，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个error时，它就知道数据还没有准备好，于是它可以再次发送read操作。一旦kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就将数据拷贝到了用户内存，然后返回。

    所以，nonblocking IO的特点是用户进程需要不断的主动询问kernel数据好了没有。
    已经可以实现多并发，从内核态拷贝到用户态还有堵塞

    3）I/O 多路复用（ IO multiplexing）

    IO multiplexing就是我们说的select，poll，epoll，有些地方也称这种IO方式为 事件驱动 IO。select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。
    这里写图片描述
    当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。

    所以，I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select()函数就可以返回。

    4）异步 I/O（asynchronous IO）

    inux下的asynchronous IO其实用得很少。先看一下它的流程：
    这里写图片描述
    用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，当它受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了。
    如同：网购之后，直接可以干别的了，之后快递就送到家门口了。

    3、总结

    阻塞IO和非阻塞IO的区别：

    • 调用阻塞会一直阻塞住对应的进程直到操作完成
    • 非阻塞 IO在kernel还准备数据的情况下会立刻返回。

    同步IO和异步IO的区别：

    • 同步 IO做”IO 操作”的时候会将进程阻塞，阻塞IO、非阻塞IO、IO多路复用都是同步IO
    • 异步则不一样，当进程发起IO 操作之后，就直接返回再也不理睬了，直到kernel发送一个信号，告诉进程说IO完成。在这整个过程中，进程完全没有被阻塞。

    4、select poll epoll IO多路复用介绍

    首先列一下，sellect、poll、epoll三者的区别

    • select
      select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。
      　
      select目前几乎在所有的平台上支持
      　
      select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。
      　
      另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

    • poll
      它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。
      一般也不用它，相当于过渡阶段

    • epoll
      直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll。被公认为Linux2.6下性能最好的多路I/O就绪通知方法。windows不支持
      　
      没有最大文件描述符数量的限制。
      比如100个连接，有两个活跃了，epoll会告诉用户这两个两个活跃了，直接取就ok了，而select是循环一遍。
      　
      （了解）epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。
      另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。
      　
      所以市面上上见到的所谓的异步IO，比如nginx、Tornado、等，我们叫它异步IO，实际上是IO多路复用。

    异步IO模块，3.0里才有，叫 asyncio

    转载请务必保留此出处：http://blog.csdn.net/fgf00/article/details/52793739

    5、select IO多路复用代码实例

    select 模拟一个socket server，注意socket必须在非阻塞情况下才能实现IO多路复用。
    接下来通过例子了解select 是如何通过单进程实现同时处理多个非阻塞的socket连接的。

    服务端

    import select
import socket
import queue

server = socket.socket()
server.bind(('localhost',9000))
server.listen(1000)

server.setblocking(False)  # 设置成非阻塞模式，accept和recv都非阻塞
# 这里如果直接 server.accept() ，如果没有连接会报错，所以有数据才调他们
# BlockIOError：[WinError 10035] 无法立即完成一个非阻塞性套接字操作。
msg_dic = {}
inputs = [server,]  # 交给内核、select检测的列表。
# 必须有一个值，让select检测，否则报错提供无效参数。
# 没有其他连接之前，自己就是个socket，自己就是个连接，检测自己。活动了说明有链接
outputs = []  # 你往里面放什么，下一次就出来了

while True:
    readable, writeable, exceptional = select.select(inputs, outputs, inputs)  # 定义检测
    #新来连接                                        检测列表         异常（断开）
    # 异常的也是inputs是： 检测那些连接的存在异常
    print(readable,writeable,exceptional)
    for r in readable:
        if r is server:  # 有数据，代表来了一个新连接
            conn, addr = server.accept()
            print("来了个新连接",addr)
            inputs.append(conn)  # 把连接加到检测列表里，如果这个连接活动了，就说明数据来了
            # inputs = [server.conn] # 【conn】只返回活动的连接，但怎么确定是谁活动了
            # 如果server活动，则来了新连接，conn活动则来数据
            msg_dic[conn] = queue.Queue()  # 初始化一个队列，后面存要返回给这个客户端的数据
        else:
            try :
                data = r.recv(1024)  # 注意这里是r，而不是conn，多个连接的情况
                print("收到数据",data)
                # r.send(data) # 不能直接发，如果客户端不收，数据就没了
                msg_dic[r].put(data)  # 往里面放数据
                outputs.append(r)  # 放入返回的连接队列里
            except ConnectionResetError as e:
                print("客户端断开了",r)
                if r in outputs:
                    outputs.remove(r) #清理已断开的连接
                inputs.remove(r) #清理已断开的连接
                del msg_dic[r] ##清理已断开的连接

    for w in writeable:  # 要返回给客户端的连接列表
        data_to_client = msg_dic[w].get()  # 在字典里取数据
        w.send(data_to_client)  # 返回给客户端
        outputs.remove(w)  # 删除这个数据，确保下次循环的时候不返回这个已经处理完的连接了。

    for e in exceptional:  # 如果连接断开，删除连接相关数据
        if e in outputs:
            outputs.remove(e)
        inputs.remove(e)
        del msg_dic[e]
 
 
    
 
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    客户端

    import socket
client = socket.socket()

client.connect(('localhost', 9000))

while True:
    cmd = input('>>> ').strip()
    if len(cmd) == 0 : continue
    client.send(cmd.encode('utf-8'))
    data = client.recv(1024)
    print(data.decode())

client.close()
 
 
    
 
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    6、selectors模块

    selectors 已经把ipoll、select封装好了，默认用epoll，如果机器上不支持epoll，比如window是不支持epoll，就用select。

    服务端

    import selectors
import socket

sel = selectors.DefaultSelector()

def accept(sock, mask):
    conn, addr = sock.accept()  # 开始连接
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)  # 连接设为非阻塞模式
    sel.register(conn, selectors.EVENT_READ, read)  # 把conn注册到sel对象里
    # 新连接回调read函数

def read(conn, mask):
    data = conn.recv(1024)  # 接收数据
    if data:
        print('echoing', repr(data), 'to', conn)
        conn.send(data)  # Hope it won't block
    else:
        print('closing', conn)
        sel.unregister(conn)  # 取消注册
        conn.close()

sock = socket.socket()
sock.bind(('localhost', 9000))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)  # 注册事件
#      sock注册过来                   新连接调用这个函数

while True:
    events = sel.select()  # 有可能调用epoll，也有可能调用select，看系统支持
    # 默认是阻塞，有活动连接，就返回活动的列表
    for key, mask in events:
        callback = key.data  # 掉accept函数
        callback(key.fileobj, mask)  # key.fileobj = 文件句柄 （相当于上个例子中检测的自己）
 
 
    
 
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    转载请务必保留此出处：http://blog.csdn.net/fgf00/article/details/52793739

网络编程之：事件驱动与异步IO
f_carey的博客
11-08 763
事件驱动与异步IO1 事件驱动模型2 同步IO和异步IO，阻塞IO和非阻塞IO2.1 基础概念2.2 I/O模式3 多路复用**select** / poll / epoll3.1 Select模拟多路复用Socket server3.2 selectors模块3.3 多发客户端 服务器处理模型有以下几种： （1）每收到一个请求，创建一个新的进程，来处理该请求；由于创建新的进程的开销比较大，会导致服务器性能比较差,但实现比较简单。 （2）每收到一个请求，创建一个新的线程，来处理该请求；由于涉及到线程的同步，
Python之进程+线程+协程（异步、selectors模块、阻塞、非阻塞IO）
12-21
`selectors`模块是Python提供的一个用于IO多路复用的工具，它提供了不同平台下的IO选择器，如`select()`、`poll()`和`epoll()`，用于统一接口处理多路IO事件。通过注册事件处理器，可以在等待IO操作的同时，让CPU...
Node.js events模块，事件驱动，异步处理(非阻塞IO)的三种方式。
houyanhua1的专栏
03-05 868
demo.js（第一种方式，异步请求改成同步请求）：var fs = require('fs'); //引入fs模块 //异步方式读取文件内容 fs.readFile('./package.json',function(error,data){ if(error){ console.log(error); return false; } ...
python3 异步模块asyncio
weixin_33906657的博客
06-22 271
yield方法引入， 这里存在的问题是，如果你想创建从0到1,000,000这样一个很大的序列，你不得不创建能容纳1,000,000个整数的列表。 但是当加入了生成器之后，你可以不用创建完整的序列，你只需要能够每次保存一个整数的内存即可。 import asyncio @asyncio.coroutine def countdown(number, n): while ...
I/O 多路复用
sheqianweilong的博客
06-19 153
首先这里只讲I/O多路复用中的epoll的用法，目的是为后续使用asyncio提前声明一些理论支撑。 对于一个I/O操作而言，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另一个就是系统内核(kernel)。当一个read/recv读数据的操作发生时，该操作会经历两个阶段： 1）等待数据准备 (Waiting for the data to be ready) 2）将数据从内核拷贝到进程中(Copying the data from the kernel to the
Nodejs 的非阻塞 I O、异步、事件驱动
郑怪兽
08-17 1060
1、 Nodejs 的单线程 非阻塞 I/O 事件驱动 在 Java、PHP 或者.net 等服务器端语言中，会为每一个客户端连接创建一个新的线程。 而每个线程需要耗费大约 2MB 内存。也就是说，理论上，一个 8GB 内存的服务器可以同时 连接的最大用户数为 4000 个左右。 要让 Web 应用程序支持更多的用户，就需要增加服务器 的数量，而 Web 应用程序的硬件成本当然就上升了。 Node.js 不为每个客户连接创建一个新的线程，而仅仅使用一个线程。 当有用户连接了， 就触发一个内部事件，通过非阻塞
Python的异步编程、IO多路复用、协程
时越的博客
09-15 225
一、异步编程 1、同步、异步 函数或方法调用的时候，被调用者是否得到最终结果的，直接得到最终结果的，就是同步调用 不直接得到最终结果的，就是异步调用 同步就是我让你打饭，你不打好给我不走开，直到你打饭给了我 异步就是我让你打饭，你打着，我不等你，但是我会盯着你，你打完，我会过来拿走，异步并不保证多长时间打完饭 2、阻塞、非阻塞 函数或方法调用的时候，是否立刻返回，立即返回就是非阻塞调用，不立即返回就是阻塞调用 同步、异步与阻塞、非阻塞不相关，同步异步强调的是结果，阻塞非阻塞强调的是时间，是否等
详解Python IO口多路复用
12-17
IO多路复用是一种高效的处理多个并发连接的技术，尤其在处理大量并发的网络连接时，如SocketServer场景。当有500个链接同时连接到服务器时，如果使用单线程处理，每个连接的IO操作（如读写数据）会依次进行，导致...
Python IO多路复用详解：实现并发与安全操作
本文将深入探讨Python中的IO多路复用技术，尤其是在高并发场景下的应用。IO多路复用（Input/Output Multiplexing）是一种在单个处理器核心上同时处理多个输入/输出操作的技术，使得单线程程序能够高效地管理大量连接...
前端学习（六）回调，异步，非阻塞，事件驱动等知识
y1yo2的博客
07-22 769
什么是回调？ 异步编程最基本的方法什么是同步/异步？什么是I/O？ 硬盘的写入写出什么是单/多线程？什么是阻塞/非阻塞？什么是事件？什么是事件驱动？什么是基于事件驱动的回调？什么是事件循环？HTTP模块： 只处理流相关操作和信息解析（请求头和请求体）
并发 IO多路复用 select 非asyncio
kyle1314608的博客
04-26 140
nodejs之事件驱动、非阻塞
wyw223的博客
01-31 247
事件驱动的模型 事件驱动的原理 原理总结： Nodejs 会把所有请求和异步操作都放到一个事件队列中，用户的每一个请求就是一个事件。主线程先把普通代码执行完毕，然后会循环事件队列里的函数，如果遇到有IO的操作，nodejs会去线程池里拿出一个线程去执行IO的操作，执行完毕后再把拿到数据的回调函数，放到事件队列的尾部，继续事件循环。 IO 操作 io操作就是以流的形式，进行的操作，比如网络请...
python--IO模块
weixin_30938149的博客
05-10 271
IO模块 一 IO模型 分为： 1 阻塞IO （accept recv） 2 非阻塞IO 3 IO多路复用（监听多个链接） 4 异步IO 5 驱动信号模型（不经常使用） 1 阻塞IO (blocking IO) 特点：全程阻塞（进程不能干其他的事儿） 当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据。对于network io...
python 管道 异步读取 select_Python高级编程与异步IO并发编程——12“select+callback+event循环获取HTML,和,123select,回调,事件,html...
weixin_36316102的博客
01-13 134
#1. 默认，阻塞IO实现http请求# requests 包基于urllib，urllib又是基于socket实现的。 凡是web请求，数据库连接，网络连接，数据通信等，最底层的实现都是基于socket实现的。# socket是操作系统提供的功能，只是不同的语言将socket封装为不同的接口而已。# 如何通过socket，完成urlib的get请求？import socketfrom urlli...
事件驱动与非阻塞模式
weixin_30918633的博客
05-29 249
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型，使其轻量又高效。 上述内容是node.js的介绍，node.js基于typescript编写，typesript是javascript的超集，所以node.js是单线程应用程序，那我们介绍一下-->什么是事件驱动。 ps:typescri...
python3socket非阻塞_基于python和socket的进程间非阻塞通信
weixin_39660931的博客
11-23 440
else:ifresult:print(result)print(address)udpsock_send.sendto(b'I am udp, I got it.',addr2)print(index)index=index+1time.sleep(1)udpsock_recv.close()udpsock_send.close()myprobe()client端：importsocketimp...
python入门第三十五天--事件驱动模型（补）练习理解
weixin_30613727的博客
09-03 560
阻塞IO 阻塞IO（blocking IO）的特点：就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了。 什么是阻塞呢？想象这种情形，比如你等快递，但快递一直没来，你会怎么做？有两种方式： 快递没来，我可以先去睡觉，然后快递来了给我打电话叫我去取就行了。 快递没来，我就不停的给快递打电话说：擦，怎么还没来，给老子快点，直到快递来。 很显然，你无法忍受第二...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值