Introduction à epoll sur la programmation réseau Python et l'apprentissage du multiplexage IO

Qu'est-ce qu'epoll

Qu'est-ce qu'epoll ? Dans la programmation réseau de linux, select est utilisé depuis longtemps pour le déclenchement d'événements. Dans le nouveau noyau Linux, il existe un mécanisme pour le remplacer, epoll. Bien sûr, cela n'est pas propre au noyau 2.6, il a été introduit dans le noyau 2.5.44 (epoll(4) est une nouvelle API introduite dans le noyau Linux 2.5.44) , elle présente presque tous les avantages mentionnés précédemment et est reconnue comme la méthode de notification d'E/S multiplexée la plus performante sous Linux2.6.

Par rapport à Select, le plus grand avantage d'epoll est qu'il ne réduira pas l'efficacité à mesure que le nombre de fds d'écoute augmente. Parce que dans l'implémentation select dans le noyau, il est traité par interrogation. Plus il y a de fds interrogés, plus cela prendra de temps.

Comment fonctionne epoll

epoll notifie également uniquement les descripteurs de fichiers prêts, et lorsque nous appelons epoll_wait() pour obtenir un descripteur de fichier prêt, ce qui est renvoyé n'est pas le descripteur réel, mais une valeur représentant le nombre de descripteurs prêts. Il vous suffit d'obtenir le nombre correspondant de descripteurs de fichiers en séquence à partir d'un tableau spécifié par epoll. La technologie de mappage de mémoire (mmap) est également utilisée ici, de sorte qu'elle soit complètement celle-ci. élimine la surcharge liée à la copie de ces descripteurs de fichiers lors des appels système.

Une autre amélioration essentielle est qu'epoll adopte une méthode de notification de préparation basée sur les événements. Dans select/poll, le noyau analyse tous les descripteurs de fichiers surveillés uniquement après que le processus a appelé une certaine méthode, tandis qu'epoll enregistre un descripteur de fichier via epoll_ctl() à l'avance. Une fois qu'un certain descripteur de fichier est prêt, le noyau utilisera un mécanisme de rappel. similaire au rappel pour activer rapidement ce descripteur de fichier, et sera averti lorsque le processus appellera epoll_wait().

Comme le montre ce qui précède, epoll est une amélioration par rapport aux modèles select et poll, qui améliore les performances de la programmation réseau et est largement utilisé dans les requêtes simultanées à grande échelle C/SArchitecture.

epoll en python

1. Méthode de déclenchement :

Déclencheur Edge/déclencheur horizontal, applicable uniquement au système d'exploitation Unix/Linux

2. Diagramme schématique

3. Étapes générales

Créer un epoll objet——Créer 1 epollObjet

Dites à l'objet epoll de surveiller des événements spécifiques sur des sockets spécifiques——Dites à l'objet epoll de surveiller des événements spécifiques sur des sockets spécifiques

Demandez à l'objet epoll quelles sockets peuvent avoir le spécifié événement depuis la dernière requête——Demandez à l'objet epoll quelles sockets ont eu l'événement spécifié depuis la dernière requête

Effectuez une action sur ces sockets—— Effectuez quelques opérations sur ces sockets

Dites à l'objet epoll de modifier la liste des sockets et/ou des événements à surveiller——Dites à l'objet epoll de modifier la liste des sockets et/ou des événements, et Monitor

Répétez les étapes 3 à 5 jusqu'à ce que vous ayez terminé——Répétez les étapes 3 à 5 jusqu'à ce que vous ayez terminé

Détruisez l'objet epoll——Détruisez l'objet epoll

Utilisation associée

importer. select Import select module

epoll = select.epoll() crée un objet epoll

epoll.register (descripteur de fichier, type d'événement) enregistre le descripteur de fichier à surveiller et Event

Type d'événement :

select.EPOLLIN Événement lisible

select.EPOLLOUT Événement inscriptible

select.EPOLLERR Événement d'erreur

　Rapport au processus utilisateur, timeout

est le délai d'expiration, la valeur par défaut est -1, c'est-à-dire que le descripteur de fichier est modifié jusqu'à ce que le descripteur de fichier change, s'il est spécifié comme 1

alors le descripteur de fichier actuel est signalé toutes les 1 secondes toutes les 1 secondes. S'il n'y a pas de changement, il retournera vide

epoll.fileno() Renvoie le descripteur du fichier de contrôle epoll (

Retour

le descripteur du fichier de contrôle epoll)

epoll. modfiy(fineno,event)fineno est le descripteur de fichier et event est le type d'événement. Sa fonction est de modifier l'événement correspondant au descripteur de fichier .

epoll.fromfd(fileno) crée un objet epoll à partir d'un descripteur de fichier spécifié

epoll.close() Ferme le descripteur de fichier de contrôle de l'objet epoll

5 Exemple : Le client envoie données et le serveur renvoie les données reçues au client

Code serveur

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import socket
import select
import Queue
#创建socket对象
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#设置IP地址复用
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
#ip地址和端口号
server_address = ("127.0.0.1", 8888)
#绑定IP地址
serversocket.bind(server_address)
#监听，并设置最大连接数
serversocket.listen(10)
print  "服务器启动成功，监听IP：" , server_address
#服务端设置非阻塞
serversocket.setblocking(False)  
#超时时间
timeout = 10
#创建epoll事件对象，后续要监控的事件添加到其中
epoll = select.epoll()
#注册服务器监听fd到等待读事件集合
epoll.register(serversocket.fileno(), select.EPOLLIN)
#保存连接客户端消息的字典，格式为{}
message_queues = {}
#文件句柄到所对应对象的字典，格式为{句柄：对象}
fd_to_socket = {serversocket.fileno():serversocket,}
while True:
  print "等待活动连接......"
  #轮询注册的事件集合，返回值为[(文件句柄，对应的事件)，(...),....]
  events = epoll.poll(timeout)
  if not events:
     print "epoll超时无活动连接，重新轮询......"
     continue
  print "有" , len(events), "个新事件，开始处理......"
  
  for fd, event in events:
     socket = fd_to_socket[fd]
     #如果活动socket为当前服务器socket，表示有新连接
     if socket == serversocket:
            connection, address = serversocket.accept()
            print "新连接：" , address
            #新连接socket设置为非阻塞
            connection.setblocking(False)
            #注册新连接fd到待读事件集合
            epoll.register(connection.fileno(), select.EPOLLIN)
            #把新连接的文件句柄以及对象保存到字典
            fd_to_socket[connection.fileno()] = connection
            #以新连接的对象为键值，值存储在队列中，保存每个连接的信息
            message_queues[connection]  = Queue.Queue()
     #关闭事件
     elif event & select.EPOLLHUP:
        print 'client close'
        #在epoll中注销客户端的文件句柄
        epoll.unregister(fd)
        #关闭客户端的文件句柄
        fd_to_socket[fd].close()
        #在字典中删除与已关闭客户端相关的信息
        del fd_to_socket[fd]
     #可读事件
     elif event & select.EPOLLIN:
        #接收数据
        data = socket.recv(1024)
        if data:
           print "收到数据：" , data , "客户端：" , socket.getpeername()
           #将数据放入对应客户端的字典
           message_queues[socket].put(data)
           #修改读取到消息的连接到等待写事件集合(即对应客户端收到消息后，再将其fd修改并加入写事件集合)
           epoll.modify(fd, select.EPOLLOUT)
     #可写事件
     elif event & select.EPOLLOUT:
        try:
           #从字典中获取对应客户端的信息
           msg = message_queues[socket].get_nowait()
        except Queue.Empty:
           print socket.getpeername() , " queue empty"
           #修改文件句柄为读事件
           epoll.modify(fd, select.EPOLLIN)
        else :
           print "发送数据：" , data , "客户端：" , socket.getpeername()
           #发送数据
           socket.send(msg)
#在epoll中注销服务端文件句柄
epoll.unregister(serversocket.fileno())
#关闭epoll
epoll.close()
#关闭服务器socket
serversocket.close()

Code client :

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import socket
#创建客户端socket对象
clientsocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#服务端IP地址和端口号元组
server_address = ('127.0.0.1',8888)
#客户端连接指定的IP地址和端口号
clientsocket.connect(server_address)
while True:
    #输入数据
    data = raw_input('please input:')
    #客户端发送数据
    clientsocket.sendall(data)
    #客户端接收数据
    server_data = clientsocket.recv(1024)
    print '客户端收到的数据：'server_data
    #关闭客户端socket
    clientsocket.close()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!