python以epoll方式实现HTTP服务器，浏览器通过HTTP与之通信6

柔光的暖阳◎ 2021-12-10 15:27 240阅读 0赞

实际开发中，由于各种原因，我们一般不会用前面演示几种方式实现多并发的web服务器,而是使用一个种更加高效的方式：epoll方式。比如nginx服务器的实现就是基于epoll方式，同样实现了非阻塞，“并发”。

### 1.什么是epoll? ###

Epoll可是当前在Linux下开发大规模并发网络程序的热门人选，Epoll 在Linux2.6内核中正式引入，和select相似，其实都**I/O多路复用技术而已**，并没有什么神秘的。

**python中通过select模块中的epoll对象实现此功能。select.epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。**

### **2.I/O 多路复用的特点** ###

通过一种机制使一个进程能同时等待多个文件描述符**(linux中一切皆文件，包扣鼠标键盘，存储操作通过文件描述符进行区分)**，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，epoll()函数就可以返回。 **所以, IO多路复用，本质上不会有并发的功能，因为任何时候还是只有一个进程或线程进行工作，它之所以能提高效率是因为select\\epoll 把进来的socket放到他们的 '监视' 列表里面，当任何socket有可读可写数据立马处理，那如果select\\epoll 手里同时检测着很多socket， 一有动静马上返回给进程处理，总比一个一个socket过来,阻塞等待,处理高效率。**

当然也可以多线程/多进程方式，一个连接过来开一个进程/线程处理，这样消耗的内存和进程切换页会耗掉更多的系统资源。 所以我们可以结合IO多路复用和多进程/多线程 来高性能并发，IO复用负责提高接受socket的通知效率，收到请求后，交给进程池/线程池来处理逻辑。

### 3.epoll模型 ###

关于epoll模式与使用 ，只需要了解其原理即可，实际开发中很少直接让你干一个epoll模型服务器。

import socket
    import select
    
    # 创建套接字
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # 设置可以重复使用绑定的信息
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
    
    # 绑定本机信息
    s.bind(("",7788))
    
    # 变为被动
    s.listen(10)
    
    # 创建一个epoll对象
    epoll = select.epoll()
    
    # 测试，用来打印套接字对应的文件描述符
    # print(s.fileno())
    # print(select.EPOLLIN|select.EPOLLET)
    
    # 注册事件到epoll中
    # epoll.register(fd[, eventmask])
    # 注意，如果fd已经注册过，则会发生异常
    # 将创建的套接字添加到epoll的事件监听中
    epoll.register(s.fileno(), select.EPOLLIN|select.EPOLLET)
    
    connections = {}
    addresses = {}
    
    # 循环等待客户端的到来或者对方发送数据
    while True:
    
        # epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
        epoll_list = epoll.poll()
    
        # 对事件进行判断
        for fd, events in epoll_list:
    
            # print fd
            # print events
    
            # 如果是socket创建的套接字被激活
            if fd == s.fileno():
                new_socket, new_addr = s.accept()
    
                print('有新的客户端到来%s' % str(new_addr))
    
                # 将 conn 和 addr 信息分别保存起来
                connections[new_socket.fileno()] = new_socket
                addresses[new_socket.fileno()] = new_addr
    
                # 向 epoll 中注册 新socket 的 可读 事件
                epoll.register(new_socket.fileno(), select.EPOLLIN|select.EPOLLET)
    
            # 如果是客户端发送数据
            elif events == select.EPOLLIN:
                # 从激活 fd 上接收
                recvData = connections[fd].recv(1024).decode("utf-8")
    
                if recvData:
                    print('recv:%s' % recvData)
                else:
                    # 从 epoll 中移除该 连接 fd
                    epoll.unregister(fd)
    
                    # server 侧主动关闭该 连接 fd
                    connections[fd].close()
                    print("%s---offline---" % str(addresses[fd]))
                    del connections[fd]
                    del addresses[fd]

**尖叫提示：**

*  EPOLLIN （可读）
 *  EPOLLOUT （可写）
 *  EPOLLET （ET模式）

**epoll效果高原因：  
1.特殊共享内存，应有程序和Kernel共享的  
2.以事件通知的方式而不是轮寻的方式进行监听。**

epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：LT模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll时，会再次响应应用程序并通知此事件。

ET模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll时，不会再次响应应用程序并通知此事件。

### 4.python以epoll方式实现前面HTTP服务器通信 ###

import socket
    import time
    import sys
    import re
    import select
    
    
    class WSGIServer(object):
        """定义一个WSGI服务器的类"""
    
        def __init__(self, port, documents_root):
    
            # 1. 创建套接字
            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            # 2. 绑定本地信息
            self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.server_socket.bind(("", port))
            # 3. 变为监听套接字
            self.server_socket.listen(128)
    
            self.documents_root = documents_root
    
            # 创建epoll对象
            self.epoll = select.epoll()
            # 将tcp服务器套接字加入到epoll中进行监听
            self.epoll.register(self.server_socket.fileno(), select.EPOLLIN|select.EPOLLET)
    
            # 创建添加的fd对应的套接字
            self.fd_socket = dict()
    
        def run_forever(self):
            """运行服务器"""
    
            # 等待对方链接
            while True:
                # epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
                epoll_list = self.epoll.poll()
    
                # 对事件进行判断
                for fd, event in epoll_list:
                    # 如果是服务器套接字可以收数据，那么意味着可以进行accept
                    if fd == self.server_socket.fileno():
                        new_socket, new_addr = self.server_socket.accept()
                        # 向 epoll 中注册 连接 socket 的 可读 事件
                        self.epoll.register(new_socket.fileno(), select.EPOLLIN | select.EPOLLET)
                        # 记录这个信息
                        self.fd_socket[new_socket.fileno()] = new_socket
                    # 接收到数据
                    elif event == select.EPOLLIN:
                        request = self.fd_socket[fd].recv(1024).decode("utf-8")
                        if request:
                            self.deal_with_request(request, self.fd_socket[fd])
                        else:
                            # 在epoll中注销客户端的信息
                            self.epoll.unregister(fd)
                            # 关闭客户端的文件句柄
                            self.fd_socket[fd].close()
                            # 在字典中删除与已关闭客户端相关的信息
                            del self.fd_socket[fd]
    
        def deal_with_request(self, request, client_socket):
            """为这个浏览器服务器"""
    
            if not request:
                return
    
            request_lines = request.splitlines()
            for i, line in enumerate(request_lines):
                print(i, line)
    
            # 提取请求的文件(index.html)
            # GET /a/b/c/d/e/index.html HTTP/1.1
            ret = re.match(r"([^/]*)([^ ]+)", request_lines[0])
            if ret:
                print("正则提取数据:", ret.group(1))
                print("正则提取数据:", ret.group(2))
                file_name = ret.group(2)
                if file_name == "/":
                    file_name = "/index.html"
    
    
            # 读取文件数据
            try:
                f = open(self.documents_root+file_name, "rb")
            except:
                response_body = "file not found, 请输入正确的url"
    
                response_header = "HTTP/1.1 404 not found\r\n"
                response_header += "Content-Type: text/html; charset=utf-8\r\n"
                response_header += "Content-Length: %d\r\n" % len(response_body)
                response_header += "\r\n"
    
                # 将header返回给浏览器
                client_socket.send(response_header.encode('utf-8'))
    
                # 将body返回给浏览器
                client_socket.send(response_body.encode("utf-8"))
            else:
                content = f.read()
                f.close()
    
                response_body = content
    
                response_header = "HTTP/1.1 200 OK\r\n"
                response_header += "Content-Length: %d\r\n" % len(response_body)
                response_header += "\r\n"
    
                # 将数据返回给浏览器
                client_socket.send(response_header.encode("utf-8")+response_body)
    
    
    # 设置服务器服务静态资源时的路径
    DOCUMENTS_ROOT = "./html"
    
    
    def main():
        """控制web服务器整体"""
        # python3 xxxx.py 7890
        if len(sys.argv) == 2:
            port = sys.argv[1]
            if port.isdigit():
                port = int(port)
        else:
            print("运行方式如: python3 xxx.py 7890")
            return
    
        print("http服务器使用的port:%s" % port)
        http_server = WSGIServer(port, DOCUMENTS_ROOT)
        http_server.run_forever()
    
    
    if __name__ == "__main__":
        main()

### 尖叫提示： ###

**      当然上面案例改进了tcp通信以长链接的方式进行的。TCP在真正的读写操作之前，server与client之间必须建立一个连接，当读写操作完成后，双方不再需要这个连接时它们可以释放这个连接，连接的建立通过三次握手，释放则需要四次挥手，所以说每个连接的建立都是需要资源消耗和时间消耗的。**

**所谓tcp长链接实际操作流程如下：**

1.  client 向 server 发起连接
2.  server 接到请求，双方建立连接
3.  client 向 server 发送消息
4.  server 回应 client
5.  一次读写完成，连接不关闭
6.  后续读写操作...
7.  长时间操作之后client发起关闭请求

这里使用了在header中添加**`Content-Length属性，告诉服务器某次请求是否完成，然后服务器在确认该次请求结束后，才会响应新的请求，否则会一直卡在哪儿。`**

统一声明：关于原创博客内容，可能会有部分内容参考自互联网，如有原创链接会声明引用；如找不到原创链接，在此声明如有侵权请联系删除哈。关于转载博客，如有原创链接会声明；如找不到原创链接，在此声明如有侵权请联系删除哈

参考文档1：[https://blog.csdn.net/sparkliang/article/details/4770655][https_blog.csdn.net_sparkliang_article_details_4770655]

[https_blog.csdn.net_sparkliang_article_details_4770655]: https://blog.csdn.net/sparkliang/article/details/4770655