epoll)

并发服务器开发

并发服务器开发，使得一个服务器可以近乎同一时刻为多个客户端提供服务。实现并发的方式有多种，下面以多进程，多线程，IO多路复用等方式实现并发。这里使用网络编程中的TCP服务器和客户端通信为例子。

多进程并发阻塞

利用进程把客户端和服务器进行管理，当有新的客户端连接到服务器时，就创建一个新的进程来管理，通过操作系统的调度，从而实现了并发的操作

from multiprocessing import Process

from socket import *

def recv_data(new_socket, client_info):

    print("客户端{}已经连接".format(client_info))

    # 接受数据

    raw_data = new_socket.recv(1024)

    while raw_data:

        print(f"收到来自{client_info}的数据：{raw_data}")

        raw_data = new_socket.recv(1024)

    new_socket.close()

def main():

    # 实例化socket对象

    socket_server = socket(AF_INET, SOCK_STREAM)

    # 设置端口复用

    socket_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

    # 绑定IP地址和端口

    socket_server.bind(("", 7788))

    # 改主动为被动，监听客户端

    socket_server.listen(5)

    while True:

        # 等待连接

        new_socket, client_info = socket_server.accept()

        p = Process(target=recv_data, args=(new_socket, client_info))

        p.start()

        # 多进程会复制父进程的内存空间，所以父进程中new_socket也必须关闭

        new_socket.close()

if __name__ == '__main__':

    main()

多线程并发阻塞

多线程和多进程类似，只是线程间共享内存空间，要注意变量的管理

from threading import Thread

from socket import *

def recv_data(new_socket, client_info):

    print("客户端{}已经连接".format(client_info))

    # 接受数据

    raw_data = new_socket.recv(1024)

    while raw_data:

        print(f"收到来自{client_info}的数据：{raw_data}")

        raw_data = new_socket.recv(1024)

    new_socket.close()

def main():

    # 实例化socket对象

    socket_server = socket(AF_INET, SOCK_STREAM)

    # 设置端口复用

    socket_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

    # 绑定IP地址和端口

    socket_server.bind(("", 7788))

    # 改主动为被动，监听客户端

    socket_server.listen(5)

    while True:

        # 等待连接

        new_socket, client_info = socket_server.accept()

        p = Thread(target=recv_data, args=(new_socket, client_info))

        p.start()

        # 多线程共享一片内存区域，所以这里不用关闭

        # new_socket.close()

if __name__ == '__main__':

    main()

多路复用IO---select模型

在操作系统层面上，系统提供了一个select接口，它会轮询给定的文件描述符状态，如果其中有描述符的状态改变，select()就会返回有变化的文件描述符。

from socket import *

import select

# 实例化对象

socket_server = socket(AF_INET, SOCK_STREAM)

# 绑定IP和端口

socket_server.bind(("", 7788))

# 将主动模式改为被动模式

socket_server.listen(5)

# 创建套接字列表

socket_lists = [socket_server]

# 等待客户端连接

while True:

    # 只监听读的状态，程序阻塞在这，不消耗CPU，如果列表里面的值读状态变化后，就解阻塞

    read_lists, _, _ = select.select(socket_lists, [], [])

    # 循环有变化的套接字

    for sock in read_lists:

        # 判断是否是主套接字

        if sock == socket_server:

            # 获取新连接

            new_socket, client_info = socket_server.accept()

            print(f"客户端：{client_info}已连接")

            # 添加到监听列表中

            socket_lists.append(new_socket)

        else:

            # 不是主客户端，即接收消息

            raw_data = sock.recv(1024)

            if raw_data:

                print(f"接收数据：{raw_data.decode('gb2312')}")

            else:

                # 如果没有数据，则客户端断开连接

                sock.close()

                # 从监听列表中删除该套接字

                socket_lists.remove(sock)

优点：良好的跨平台支持

缺点：1.监测的文件描述符数量有最大限制，Linux系统一般为1024，可以修改宏定义或者内核进行修改，但是会造成效率低下；2.对文件描述符采用轮询机制，每个文件描述符都会询问一遍，这样很消耗CPU时间

多路复用IO---epoll模型

为了解决select轮询机制造成的效率低下问题，则引入了epoll接口。相较于select的两大优势。1.没有文件描述符最大数量的限制(最大数量则看内存大小)；2.采用时间通知机制，当文件描述符状态有变时，主动通知内核进行调度。其中print注释是为了打印对象，查看对象是什么。

from socket import *

import select

# 创建socket对象

sock_server = socket(AF_INET, SOCK_STREAM)

# 绑定IP和端口

sock_server.bind(("", 7788))

# 将主动模式设置为被动模式，监听连接

sock_server.listen(5)

# 创建epoll监测对象

epoll = select.epoll()

# print("未注册epoll对象：{}".format(epoll))

# 注册主套接字,监控读状态

epoll.register(sock_server.fileno(), select.EPOLLIN)

# print("注册了主套接字后：{}".format(epoll))

# 创建字典，保存套接字对象

sock_dicts = {}

# 创建字典，保存客户端信息

client_dicts = {}

while True:

    # print("所有套接字：{}".format(sock_dicts))

    # print("所有客户端信息：{}".format(client_dicts))

    # 程序阻塞在这，返回文件描述符有变化的对象

    poll_list = epoll.poll()

    # print("有变化的套接字：{}".format(poll_list))

    for sock_fileno, events in poll_list:

        # print("文件描述符：{}，事件：{}".format(sock_fileno, events))

        # 判断是否是主套接字

        if sock_fileno == sock_server.fileno():

            # 创建新套接字

            new_sock, client_info = sock_server.accept()

            print(f"客户端：{client_info}已连接")

            # 注册到epoll监测中

            epoll.register(new_sock.fileno(), select.EPOLLIN)

            # 添加到套接字字典当中

            sock_dicts[new_sock.fileno()] = new_sock

            client_dicts[new_sock.fileno()] = client_info

        else:

            # 接收消息

            raw_data = sock_dicts[sock_fileno].recv(1024)

            if raw_data:

                print(f"来自{client_dicts[sock_fileno]}的数据：{raw_data.decode('gb2312')}")

            else:

                # 关闭连接

                sock_dicts[sock_fileno].close()

                # 注销epoll监测对象

                epoll.unregister(sock_fileno)

                # 数据为空，则客户端断开连接，删除相关数据

                del sock_dicts[sock_fileno]

                del client_dicts[sock_fileno]

IO多路复用和线程池在提高并发性上应用场景的区别

多路复用适用于需要保持大量闲置（区别于计算密集型）长连接的业务场景，例如聊天室。这样的好处是能够避免不断的创建新线程，导致系统资源浪费。需要注意，多路复用本质上是复用单线程的，回调函数的执行必然是有可能长时间阻塞的，所以如果涉及到耗时的计算密集型任务，则会大大降低系统处理其它连接的响应速度。

线程池则适合短连接并发的情况，比如普通的web业务系统，Tomcat的Servlet容器默认选择就是线程池（虽然3.0后支持异步，但一般情况下不常使用）。由于处理短连接的线程很快会退出，因此能够充分发挥线程池复用线程的好处。

当然，多路复用和线程池可以结合起来使用，效果也许更好，但代码复杂度也会相应提高，需要更好的设计。建议根据业务场景选择相应的技术，避免过早优化。

一点补充：很多人不知道协程该归于哪个技术范畴。协程除了在用户态通过栈切换实现控制流的切换以外，还通常将多路复用和线程池结合起来。比如go语言内置的协程就是在多线程的基础上实现了一套调度策略，调度策略的实现建立在操作系统内核提供的IO多路复用技术之上，同时go语言参考计算机硬件情况自动将协程绑定在若干个系统线程之上，从而实现资源的高效率利用。