1

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

1

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

1

2

3

4

5

6

7

8

9

10

11

保存处理机上下文，包括程序计数器和其他寄存器。

更新PCB信息。

把进程的PCB移入相应的队列，如就绪、在某事件阻塞等队列。

选择另一个进程执行，并更新其PCB。

更新内存管理的数据结构。

恢复处理机上下文。

1

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

1

2

3

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

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

1

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

1

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

1

2

3

第一阶段：等待数据准备 (Waiting for the data to be ready)。

第二阶段：将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)。

1

2

3

第一步：通常涉及等待网络上的数据分组到达，然后被复制到内核的某个缓冲区。

第二步：把数据从内核缓冲区复制到应用进程缓冲区。

1

2

3

4

5

6

7

8

9

BIO – 阻塞模式I/O（bloking IO）

NIO – 非阻塞模式I/O（non-blocking IO）

IO Multiplexing - I/O多路复用模型（multiplexing IO）

AIO – 异步I/O模型（asynchronous IO）

SIO - 信号驱动I/OM模型（signal-driven IO）

1

2

3

4

5

6

7

8

9

10

11

12

13

'''

举个例子：一个人去 商店买一把菜刀，

他到商店问老板有没有菜刀（发起系统调用）

如果有（表示在内核缓冲区有需要的数据）

老板直接把菜刀给买家（从内核缓冲区拷贝到用户缓冲区）

这个过程买家一直在等待

如果没有，商店老板会向工厂下订单（IO操作，等待数据准备好）

工厂把菜刀运给老板（进入到内核缓冲区）

老板把菜刀给买家（从内核缓冲区拷贝到用户缓冲区）

这个过程买家一直在等待

是同步io

'''

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

import socket

server = socket.socket()

server.bind(('127.0.0.1',8080))

server.listen(5)

while True:

    conn, addr = server.accept()

    while True:

        try:

            data = conn.recv(1024)

            if len(data) == 0:break

            print(data)

            conn.send(data.upper())

        except ConnectionResetError as e:

            break

    conn.close()

# 在服务端开设多进程或者多线程 进程池线程池 其实还是没有解决IO问题   

该等的地方还是得等 没有规避

只不过多个人等待的彼此互不干扰

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

'''

举个例子：一个人去 商店买一把菜刀，

他到商店问老板有没有菜刀（发起系统调用）

老板说没有，在向工厂进货（返回状态）

买家去别地方玩了会，又回来问，菜刀到了么（发起系统调用）

老板说还没有（返回状态）

买家又去玩了会（不断轮询）

最后一次再问，菜刀有了（数据准备好了）

老板把菜刀递给买家（从内核缓冲区拷贝到用户缓冲区）

整个过程轮询+等待：轮询时没有等待，可以做其他事，从内核缓冲区拷贝到用户缓冲区需要等待

是同步io

同一个线程，同一时刻只能监听一个socket，造成浪费，引入io多路复用，同时监听读个socket

'''

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

"""

要自己实现一个非阻塞IO模型

"""

import socket

import time

server = socket.socket()

server.bind(('127.0.0.1', 8081))

server.listen(5)

server.setblocking(False)

# 将所有的网络阻塞变为非阻塞

r_list = []

del_list = []

while True:

    try:

        conn, addr = server.accept()

        r_list.append(conn)

    except BlockingIOError:

        # time.sleep(0.1)

        # print('列表的长度:',len(r_list))

        # print('做其他事')

        for conn in r_list:

            try:

                data = conn.recv(1024)  # 没有消息 报错

                if len(data) == 0:  # 客户端断开链接

                    conn.close()  # 关闭conn

                    # 将无用的conn从r_list删除

                    del_list.append(conn)

                    continue

                conn.send(data.upper())

            except BlockingIOError:

                continue

            except ConnectionResetError:

                conn.close()

                del_list.append(conn)

        # 挥手无用的链接

        for conn in del_list:

            r_list.remove(conn)

        del_list.clear()

# 客户端

import socket

client = socket.socket()

client.connect(('127.0.0.1',8081))

while True:

    client.send(b'hello world')

    data = client.recv(1024)

    print(data)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

'''

举个例子：多个人去 一个商店买菜刀，

多个人给老板打电话，说我要买菜刀（发起系统调用）

老板把每个人都记录下来（放到select中）

老板去工厂进货（IO操作）

有货了，再挨个通知买到的人，来取刀（通知/返回可读条件）

买家来到商店等待，老板把到给买家（从内核缓冲区拷贝到用户缓冲区）

多路复用：老板可以同时接受很多请求（select模型最大1024个，epoll模型），

但是老板把到给买家这个过程，还需要等待，

是同步io

强调：

1. 如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。

2. 在多路复用模型中，对于每一个socket，一般都设置成为non-blocking，但是，如上图所示，整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。

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

'''

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

"""

当监管的对象只有一个的时候 其实IO多路复用连阻塞IO都比比不上！！！

但是IO多路复用可以一次性监管很多个对象

server = socket.socket()

conn,addr = server.accept()

监管机制是操作系统本身就有的 如果你想要用该监管机制(select)

需要你导入对应的select模块

"""

import socket

import select

server = socket.socket()

server.bind(('127.0.0.1',8080))

server.listen(5)

server.setblocking(False)

read_list = [server]

while True:

    r_list, w_list, x_list = select.select(read_list, [], [])

    """

    帮你监管

    一旦有人来了 立刻给你返回对应的监管对象

    """

    # print(res)  # ([<socket.socket fd=3, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080)>], [], [])

    # print(server)

    # print(r_list)

    for i in r_list:  #

        """针对不同的对象做不同的处理"""

        if i is server:

            conn, addr = i.accept()

            # 也应该添加到监管的队列中

            read_list.append(conn)

        else:

            res = i.recv(1024)

            if len(res) == 0:

                i.close()

                # 将无效的监管对象 移除

                read_list.remove(i)

                continue

            print(res)

            i.send(b'heiheiheiheihei')

 # 客户端

import socket

client = socket.socket()

client.connect(('127.0.0.1',8080))

while True:

    client.send(b'hello world')

    data = client.recv(1024)

    print(data)

1

2

3

4

5

6

7

select，poll，epoll都是IO多路复用的机制，I/O多路复用就是通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知应用程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。三者的原型如下所示：

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

（1）使用copy_from_user从用户空间拷贝fdset到内核空间

（2）注册回调函数__pollwait

（3）遍历所有fd，调用其对应的poll方法（对于socket，这个poll方法是sock_poll，sock_poll根据情况会调用到tcp_poll,udp_poll或者datagram_poll）

（4）以tcp_poll为例，其核心实现就是__pollwait，也就是上面注册的回调函数。

（5）__pollwait的主要工作就是把current（当前进程）挂到设备的等待队列中，不同的设备有不同的等待队列，对于tcp_poll 来说，其等待队列是sk->sk_sleep（注意把进程挂到等待队列中并不代表进程已经睡眠了）。在设备收到一条消息（网络设备）或填写完文件数 据（磁盘设备）后，会唤醒设备等待队列上睡眠的进程，这时current便被唤醒了。

（6）poll方法返回时会返回一个描述读写操作是否就绪的mask掩码，根据这个mask掩码给fd_set赋值。

（7）如果遍历完所有的fd，还没有返回一个可读写的mask掩码，则会调用schedule_timeout是调用select的进程（也就是 current）进入睡眠。当设备驱动发生自身资源可读写后，会唤醒其等待队列上睡眠的进程。如果超过一定的超时时间（schedule_timeout 指定），还是没人唤醒，则调用select的进程会重新被唤醒获得CPU，进而重新遍历fd，判断有没有就绪的fd。

（8）把fd_set从内核空间拷贝到用户空间。

1

2

3

4

5

（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大

（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大

（3）select支持的文件描述符数量太小了，默认是1024

1

2

3

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

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

1

2

3

4

5

6

7

8

9

10

直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。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察看,一般来说这个数目和系统内存关系很大。　　

1

2

3

4

5

（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内 部定义的等待队列），这也能节省不少的开销。

注：这三种IO多路复用模型在不同的平台有着不同的支持，而epoll在windows下就不支持，好在我们有selectors模块，帮我们默认选择当前平台下最合适的

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

'''

举个例子：还是买菜刀

现在是网上下单到商店（系统调用）

商店确认（返回）

商店去进货（io操作）

商店收到货把货发个卖家（从内核缓冲区拷贝到用户缓冲区）

买家收到货（指定信号）

整个过程无等待

异步io

AIO框架在windows下使用windows IOCP技术，在Linux下使用epoll多路复用IO技术模拟异步IO

市面上多数的高并发框架，都没有使用异步io而是用的io多路复用，因为io多路复用技术很成熟且稳定，并且在实际的使用过程中，异步io并没有比io多路复用性能提升很多，没有达到很明显的程度

并且，真正的AIO编码难度比io多路复用高很多

'''