在Python中如何使用Linux的epoll

最新推荐文章于 2024-06-15 09:41:13 发布
最新推荐文章于 2024-06-15 09:41:13 发布
阅读量1.9k 收藏 5
点赞数
分类专栏： 转载python博文 文章标签： epoll select python


阻塞socket编程示例

示例1用python3.0搭建了一个简单的服务：在8080端口监听HTTP请求，把它打印到控制台，并返回一个HTTP响应消息给客户端。

  1. 第9行：创建服务器socket。
  2. 第10行：允许在11行使用bind()来监听指定端口，即使这个端口最近被其他程序监听。没有这个设置的话，服务不能运行，直到一两分钟后，这个端口不再被之前的程序使用。
  3. 第11行：监听这台机器所有可用的IPv4地址上面的8080端口。
  4. 第12行：通知服务端socket开始接受来自客户端的连接。
  5. 第 14行：这行代码直到接收到一个客户端连接才会完成。这时，服务端socket会在服务端机器上面创建一个新的socket，用来和客户端通信。这个新的 socket在代码里面就是accept()调用返回的clientconnection 对象。返回的address对象代表着客户端的IP和端口。
  6. 第15-17行：组装从客户端传输过来的数据，直到HTTP请求完成。HTTP协议可以参考这里。
  7. 第18行：把请求打印到控制台，验证操作是否正确。
  8. 第19行：发送响应回客户端。
  9. 第20-22行：关闭和客户端的连接以及服务端监听socket。

(All examples use Python 3)

import socket

EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
response += b'Hello, world!'

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('0.0.0.0', 8080))
serversocket.listen(1)

connectiontoclient, address = serversocket.accept()
request = b''
while EOL1 not in request and EOL2 not in request:
	request += connectiontoclient.recv(1024)
print(request.decode())
connectiontoclient.send(response)
connectiontoclient.close()

serversocket.close()

示例2在15行增加了一个循环来不断的处理来自客户端的连接，直到用户中断（比如键盘中断）。这个例子更清楚的说明服务端socket从不和客户端交换数据。相反的，它接收客户端的连接，然后在这台服务器上面创建一个新的socket用来和客户端通信。

在23-24行的finally语句，可以确保服务端负责监听的socket会关闭，即使有异常发生。

Example 2

import socket

EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
response += b'Hello, world!'

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('0.0.0.0', 8080))
serversocket.listen(1)

try:
    while True:
	connectiontoclient, address = serversocket.accept()
	request = b''
	while EOL1 not in request and EOL2 not in request:
	    request += connectiontoclient.recv(1024)
	print('-'*40 + '\n' + request.decode()[:-2])
	connectiontoclient.send(response)
	connectiontoclient.close()
finally:
    serversocket.close()

异步socket的好处以及Linux epoll

示 例2中的socket叫做阻塞socket，因为python程序会停止运行，直到一个event发生。16行的accept()调用会阻塞，直到接收到 一个客户端连接。19行的recv()调用会阻塞，直到这次接收客户端数据完成（或者没有更多的数据要接收）。21行的send()调用也会阻塞，直到将 这次需要返回给客户端的数据都放到Linux的发送缓冲队列中。

当 一个程序使用阻塞socket时，常常使用一个线程（甚至是一个专门的程序）来进行各个socket之间的通信。主程序线程会包含接收客户端连接的服务端 监听socket。这个socket一次接收一个客户端连接，把连接传给另外一个线程新建的socket去处理。因为这些线程每个只和一个客户端通信，所 以处理时即便在某几个点阻塞也没有关系。这种阻塞并不会对其他线程的处理造成任何影响。

使用多线程、阻塞socket来处理的话，代码会很直观，但是也会有不少缺陷。它很难确保线程共享资源没有问题。而且这种编程风格的程序在只有一个CPU的电脑上面效率更低。

C10K问题探讨了一些替代选择，其一是使用示例3重复了示例2的功能，同时使用异步socket。这个程序更为复杂，因为一个线程要交错与多个客户端通信。

  1. 第1行：select模块包含epoll功能。
  2. 第13行：因为socket默认是阻塞的，所以需要使用非阻塞（异步）模式。
  3. 第15行：创建一个epoll对象。
  4. 第16行：在服务端socket上面注册对读event的关注。一个读event随时会触发服务端socket去接收一个socket连接。
  5. 第19行：字典connections映射文件描述符（整数）到其相应的网络连接对象。
  6. 第21行：查询epoll对象，看是否有任何关注的event被触发。参数“1”表示，我们会等待1秒来看是否有event发生。如果有任何我们感兴趣的event发生在这次查询之前，这个查询就会带着这些event的列表立即返回。
  7. 第22行：event作为一个序列（fileno，event code）的元组返回。fileno是文件描述符的代名词，始终是一个整数。
  8. 第23行：如果一个读event在服务端sockt发生，就会有一个新的socket连接可能被创建。
  9. 第25行：设置新的socket为非阻塞模式。
  10. 第26行：为新的socket注册对读（EPOLLIN）event的关注。
  11. 第31行：如果发生一个读event，就读取从客户端发送过来的新数据。
  12. 第33行：一旦完成请求已收到，就注销对读event的关注，注册对写（EPOLLOUT）event的关注。写event发生的时候，会回复数据给客户端。
  13. 第34行：打印完整的请求，证明虽然与客户端的通信是交错进行的，但数据可以作为一个整体来组装和处理。
  14. 第35行：如果一个写event在一个客户端socket上面发生，它会接受新的数据以便发送到客户端。
  15. 第36-38行：每次发送一部分响应数据，直到完整的响应数据都已经发送给操作系统等待传输给客户端。
  16. 第39行：一旦完整的响应数据发送完成，就不再关注读或者写event。
  17. 第40行：如果一个连接显式关闭，那么socket shutdown是可选的。本示例程序这样使用，是为了让客户端首先关闭。shutdown调用会通知客户端socket没有更多的数据应该被发送或接收，并会让功能正常的客户端关闭自己的socket连接。
  18. 第41行：HUP（挂起）event表明客户端socket已经断开（即关闭），所以服务端也需要关闭。没有必要注册对HUP event的关注。在socket上面，它们总是会被epoll对象注册。
  19. 第42行：注销对此socket连接的关注。
  20. 第43行：关闭socket连接。
  21. 第18-45行：使用try-catch，因为该示例程序最有可能被KeyboardInterrupt异常中断。
  22. 第46-48行：打开的socket连接不需要关闭，因为Python会在程序结束的时候关闭。这里显式关闭是一个好的代码习惯。

 

Example 3

 

import socket, select

EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
response += b'Hello, world!'

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('0.0.0.0', 8080))
serversocket.listen(1)
serversocket.setblocking(0)

epoll = select.epoll()
epoll.register(serversocket.fileno(), select.EPOLLIN)

try:
    connections = {}; requests = {}; responses = {}
    while True:
        events = epoll.poll(1)
         for fileno, event in events:
             if fileno == serversocket.fileno():
                 connection, address = serversocket.accept()
                 connection.setblocking(0)
                 epoll.register(connection.fileno(), select.EPOLLIN)
                 connections[connection.fileno()] = connection
                 requests[connection.fileno()] = b''
                 responses[connection.fileno()] = response
            elif event & select.EPOLLIN:
                 requests[fileno] += connections[fileno].recv(1024)
                 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
                 epoll.modify(fileno, select.EPOLLOUT)
                 print('-'*40 + '\n' + requests[fileno].decode()[:-2])
            elif event & select.EPOLLOUT:
                byteswritten = connections[fileno].send(responses[fileno])
                responses[fileno] = responses[fileno][byteswritten:]
                if len(responses[fileno]) == 0:
                    epoll.modify(fileno, 0)
                    connections[fileno].shutdown(socket.SHUT_RDWR)
            elif event & select.EPOLLHUP:
                epoll.unregister(fileno)
                connections[fileno].close()
                del connections[fileno]
finally:
     epoll.unregister(serversocket.fileno())
     epoll.close()
     serversocket.close()

epoll有两种操作模式，称为水平触发 。在边沿触发模式中，epoll.poll（）在读或者写event在socket上面发生后，将只会返回一次event。调用epoll.poll() 的程序必须处理所有和这个event相关的数据，随后的epoll.poll()调用不会再有这个event的通知。当一个特定event的数据耗尽时， 进一步尝试操作socket将导致一个异常。相反，在水平触发模式下，重复调用epoll.poll（）会重复通知关注的event，直到与该event 有关的所有数据都已被处理。在水平模式下通常没有异常。

例如， 假设一个服务端socket已经为一个epoll对象注册了读event。在边沿触发模式下，程序需要一直accept()新的socket连接，直到一 个socket.error的异常发生。而在水平触发模式下，一个accept()调用后，epoll对象会被服务端socket再次询问是否有新的 event，以确定下一个accept()是否应该被调用。

示 例3使用水平触发模式，这是操作的默认模式。示例4演示了如何使用边沿触发模式。在示例4中，第25，36和45行引入循环，直到出现异常才退出（或者所 有其他已知的数据都被处理）。第32，38和48行捕获预期的socket异常。最后，第16，28，41和51行添加EPOLLET掩码，用来设置为边 沿触发模式。

Example 4

import socket, select

EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
response += b'Hello, world!'

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('0.0.0.0', 8080))
serversocket.listen(1)
serversocket.setblocking(0)

epoll = select.epoll()
epoll.register(serversocket.fileno(), select.EPOLLIN | select.EPOLLET)

try:
    connections = {}; requests = {}; responses = {}
    while True:
        events = epoll.poll(1)
        for fileno, event in events:
             if fileno == serversocket.fileno():
                try:
                     while True:
                          connection, address = serversocket.accept()
                          connection.setblocking(0)
                          epoll.register(connection.fileno(), select.EPOLLIN | select.EPOLLET)
                          connections[connection.fileno()] = connection
                          requests[connection.fileno()] = b''
                          responses[connection.fileno()] = response
                except socket.error:
                     pass
            elif event & select.EPOLLIN:
                 try:
                     while True:
                          requests[fileno] += connections[fileno].recv(1024)
                 except socket.error:
                     pass
                 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
                      epoll.modify(fileno, select.EPOLLOUT | select.EPOLLET)
                      print('-'*40 + '\n' + requests[fileno].decode()[:-2])
             elif event & select.EPOLLOUT:
                 try:
                     while len(responses[fileno]) > 0:
                         byteswritten = connections[fileno].send(responses[fileno])
                         responses[fileno] = responses[fileno][byteswritten:]
                 except socket.error:
                      pass
                  if len(responses[fileno]) == 0:
                     epoll.modify(fileno, select.EPOLLET)
                     connections[fileno].shutdown(socket.SHUT_RDWR)
              elif event & select.EPOLLHUP:
                  epoll.unregister(fileno)
                  connections[fileno].close()
                  del connections[fileno]
finally:
     epoll.unregister(serversocket.fileno())
     epoll.close()
     serversocket.close()

这两种模式是类似的，水平触发模式常被用在移植使用select或者poll机制的应用程序时，而边沿触发模式可以用在当程序员不需要或不想要操作系统协助管理event状态时。

除了这两种操作模式，epoll对象也可以注册socket使用EPOLLONESHOTevent掩码。当使用这个选项时，注册的event只适用于一个epoll.poll()调用，调用之后它会自动从被监视的socket注册列表中移除。

Example 5

import socket, select

EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
response += b'Hello, world!'

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('0.0.0.0', 8080))
serversocket.listen(1)
serversocket.setblocking(0)

epoll = select.epoll()
epoll.register(serversocket.fileno(), select.EPOLLIN)

try:
     connections = {}; requests = {}; responses = {}
     while True:
         events = epoll.poll(1)
         for fileno, event in events:
             if fileno == serversocket.fileno():
                 connection, address = serversocket.accept()
                 connection.setblocking(0)
                 epoll.register(connection.fileno(), select.EPOLLIN)
                 connections[connection.fileno()] = connection
                 requests[connection.fileno()] = b''
                 responses[connection.fileno()] = response
             elif event & select.EPOLLIN:
                 requests[fileno] += connections[fileno].recv(1024)
                 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
                     epoll.modify(fileno, select.EPOLLOUT)
                     connections[fileno].setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1)
                     print('-'*40 + '\n' + requests[fileno].decode()[:-2])
             elif event & select.EPOLLOUT:
                 byteswritten = connections[fileno].send(responses[fileno])
                 responses[fileno] = responses[fileno][byteswritten:]
                 if len(responses[fileno]) == 0:
                     connections[fileno].setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 0)
                     epoll.modify(fileno, 0)
                     connections[fileno].shutdown(socket.SHUT_RDWR)
             elif event & select.EPOLLHUP:
                 epoll.unregister(fileno)
                 connections[fileno].close()
                 del connections[fileno]
finally:
     epoll.unregister(serversocket.fileno())
     epoll.close()
     serversocket.close()

另一方面， TCP_NODELAY选项可以用来告诉操作系统，任何传递给socket.send()的数据，不再缓存，要立即发送给客户端。如示例6的14行所示，这个选项对于使用一个SSH客户端或其他“实时”应用来说，可能是一个很好的选择。

Example 6

import socket, select

EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
response += b'Hello, world!'

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('0.0.0.0', 8080))
serversocket.listen(1)
serversocket.setblocking(0)
serversocket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

epoll = select.epoll()
epoll.register(serversocket.fileno(), select.EPOLLIN)

try:
     connections = {}; requests = {}; responses = {}
     while True:
         events = epoll.poll(1)
         for fileno, event in events:
             if fileno == serversocket.fileno():
                 connection, address = serversocket.accept()
                 connection.setblocking(0)
                 epoll.register(connection.fileno(), select.EPOLLIN)
                 connections[connection.fileno()] = connection
                 requests[connection.fileno()] = b''
                 responses[connection.fileno()] = response
             elif event & select.EPOLLIN:
                 requests[fileno] += connections[fileno].recv(1024)
                 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
                     epoll.modify(fileno, select.EPOLLOUT)
                     print('-'*40 + '\n' + requests[fileno].decode()[:-2])
             elif event & select.EPOLLOUT:
                 byteswritten = connections[fileno].send(responses[fileno])
                 responses[fileno] = responses[fileno][byteswritten:]
                 if len(responses[fileno]) == 0:
                 epoll.modify(fileno, 0)
                 connections[fileno].shutdown(socket.SHUT_RDWR)
             elif event & select.EPOLLHUP:
                 epoll.unregister(fileno)
                 connections[fileno].close()
                 del connections[fileno]
finally:
     epoll.unregister(serversocket.fileno())
     epoll.close()
     serversocket.close()


二代超人
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python epoll多路复用_多路复用（一）：epoll原理
weixin_35487052的博客
03-01 786
公众号：灰子学技术(Go语言，架构相关知识，正在同步更新中-ing)epoll的系统调用很简单，只有三个，其定义如下：int epoll_create(int size);int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);int epoll_wait(int epfd, struct epoll_event *ev...
python实现Linux异步epoll代码
01-20
if __name__==”__main__”: s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) s.bind((“”,20123)) s.listen(10) epoll=select.epoll() print s...
python 使用 epoll
逆雪寒的天坑
08-02 6231
序言 从2.6开始，Python包含了访问Linux epoll库的API。这篇文章用几个简单的python 3例子来展示下这个API。欢迎大家质疑和反馈。 阻塞socket编程示例 示例1用python3.0搭建了一个简单的服务：在8080端口监听HT
Ubuntu安装教程（非常详细）从零基础入门到精通，看完这一篇就够了
最新发布
bdfcfff77fa的博客
06-15 1975
内容概要：包括 内网、操作系统、协议、渗透测试、安服、漏洞、注入、XSS、CSRF、SSRF、文件上传、文件下载、文件包含、XXE、逻辑漏洞、工具、SQLmap、NMAP、BP、MSF…技术文档也是我自己整理的，包括我参加大型网安行动、CTF和挖SRC漏洞的经验和技术要点，电子书也有200多本，由于内容的敏感性，我就不一一展示了。网上虽然也有很多的学习资源，但基本上都残缺不全的，这是我自己录的网安视频教程，上面路线图的每一个知识点，我都有配套的视频讲解。安装时间好长哦，那还不多背几个单词!
How To Use Linux epoll with Python
WHACKW的专栏
01-13 1053
How To Use Linux epoll with Python Contents IntroductionBlocking Socket Programming ExamplesBenefits of Asynchronous Sockets and Linux epollAsynchronous Socket Programming Examples with ep
在 Python 中使用 Epoll
03-26 160
在 Python 中使用 Epoll 在 Python 中使用 epoll - Log4D在 Python 中使用 Epoll2013/01/12 | Comments原文地址： http://scotdoyle.com/pyth...
python 网络编程之epoll使用
热门推荐
Dream home
10-08 1万+
 从以上可知，epoll是对select、poll模型的改进，提高了网络编程的性能，广泛应用于大规模并发请求的C/S架构中。   1、触发方式：      边缘触发/水平触发，只适用于Unix/Linux操作系统    2、原理图   3、一般步骤 Create an epoll object——创建1个epoll对象 Tell the epoll object to monito...
使用epoll开发python服务器
03-23
在Python中开发高性能的网络服务器时，`epoll`是Linux系统提供的一种I/O多路复用技术。它允许程序同时监视多个文件描述符，一旦某个文件描述符就绪（例如，有数据可读或可写），`epoll`就会通知程序。这种方式提高了...
python-epoll-examples
10-08
在这个"python-epoll-examples"压缩包中，我们可以找到一系列关于如何在Python中使用epoll的示例代码。 首先，epoll是一种I/O事件通知机制，通过它，程序可以监控多个文件描述符（如socket、管道、文件等），当这些...
python_epoll_timer.rar
09-30
2. `ctypes`库的使用，用于在Python中调用C语言的动态链接库，实现对epoll的低级别操作。 3. Linux的epoll API，包括`epoll_create`, `epoll_ctl`, `epoll_wait`等函数的用法。 4. Python的多线程或多进程编程，可能...
python epoll
lxyjj的博客
12-05 720
事件驱动模型 事件驱动编程是一种网络编程范式，程序的执行流由外部事件来决定。它的特点是包含一个事件循环，程序可能关注多种事件，在事件循环中不断去轮询监控各种事件，如果某个事件发生，则调用该事件注册的回掉函数。 影响事件驱动模型的两点 轮询各种事件的效率：如果时间循环在查询某个事件时阻塞了，那么当其它事件到达时势必无法及时响应，影响性能。 回掉函数的效率：如果回掉函数在处理某个事件时用时较长...
DASD_116.torrent
12-19
DASD_116.torrent
python之利用epoll实现http服务器
Jary
07-02 836
#!/usr/bin/python3.5 # -*- coding: utf-8 -*- # @Time : 18-7-2 下午7:39 # @Author : "Fengwr" # @email : fengwenrui1217@163.com # @File : epoll实现http.py # @Software: PyCharm import socket import...
【Python基础】网络编程之Epoll使用一（符实操：基于epoll实现的实时聊天室）
广西彭于晏的博客
11-13 422
epoll”是输入/输出事件通知的系统调用。它是 Linux 内核提供的一项功能，用于有效处理大量文件描述符或套接字。“epoll”在需要监视许多 I/O 操作的情况下特别有用，例如在处理大量并发连接的服务器中。与“select”和“poll”等旧机制不同，“epoll”旨在随着文件描述符的数量而有效扩展。它特别适用于具有大量开放套接字的方案。‘epoll’ 是事件驱动的，这意味着当文件描述符上发生特定事件时，它可以通知您的程序。事件可以包括可供读取的数据、可供写入的空间或文件描述符上的错误。
python epoll 并发_Python语言之python并发原理（阻塞、非阻塞、epoll）
weixin_39616287的博客
11-28 106
本文主要向大家介绍了Python语言之python并发原理（阻塞、非阻塞、epoll），通过具体的内容向大家展示，希望对大家学习Python语言有所帮助。在Linux系统中01 阻塞服务端特征：1对1，阻塞。1 import socket23 server = socket.socket() #生成套接字对象4 server.bind(('0.0.0.0', 8000)) #套...
python使用epoll实现的服务端例子
Linux C/C++后台开发
09-22 1175
#!/usr/bin/python # -*- coding: UTF-8 -*- import socket import selectsend_data = "hello world!" send_len = len(send_data) recv_len = 1024 tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Python epoll服务器
qq_31629063的博客
11-25 297
import socket import select import multiprocessing def main(): sSocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) sSocket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True) s...
python epoll多路复用技术_Python—IO多路复用之epoll总结
weixin_39636987的博客
12-10 309
一、epoll接口epoll操作过程需要三个接口，分别如下：1. int epoll_create(int size);创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大，这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值，参数size并不是限制了epoll所能监听的描述符最大个数，只是对内核初始分配内部数据结构的一个建议。需要注意的是，当创建好epoll...
Python-网络编程：epoll
bluebloodye的专栏
09-26 207
简单说（什么是epoll） epoll（采用单进程单线程，非阻塞的高并发，不过比我们之前写的更高级），它有一个特色内存，这个内存是应用程序和kernel内核共享，对于这个内存中要监听的要判断数据是否到来的套接字所对应的文件描述符采用事件通知的方式（而不是轮训的方式）。 epoll版的http（掌握思想） ...
epoll python
09-19
在Python中，我们可以使用epoll API来访问Linux的epoll库。与select和poll相比，epoll具有更高的效率和可扩展性。它通过依赖操作系统来告知程序哪些socket可能有感兴趣的事件，而不需要程序检查每个socket的事件。当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值