epoll de multiplexage IO de Python

Qu'est-ce qu'epoll

Qu'est-ce qu'epoll ? Dans la programmation réseau 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 unique au noyau Linux 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). 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, éliminant ainsi complètement la surcharge de la copie de caractères. pendant les 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 des modèles de sélection et d'interrogation, qui améliore les performances de la programmation réseau et est largement utilisé dans les architectures C/S avec des requêtes simultanées à grande échelle.

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.

3. Étapes générales

Créer un objet epoll——Créer un objet epoll

Dites à l'objet epoll de surveiller des événements spécifiques sur sockets spécifiques - Dites à l'objet epoll d'écouter l'événement spécifié sur la socket spécifiée

Demandez à l'objet epoll quelles sockets peuvent avoir eu l'événement spécifié depuis la dernière requête - Demandez à l'objet epoll, depuis la dernière requête Depuis la requête, quels événements spécifiés se sont produits sur quelles sockets

Effectuer une action sur ces sockets——Effectuer certaines opérations sur ces sockets

Dites à l'objet epoll de modifier la liste des sockets et/ou événements à surveiller - indiquez l'objet epoll, modifiez la liste des sockets et/ou les événements et surveillez

Répétez les étapes 3 à 5 jusqu'à la fin - Répétez les étapes 3 à 5 jusqu'à la fin

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

4. Utilisation associée

import select Import select module

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

epoll.register (descripteur de fichier, type d'événement) enregistre les descripteurs de fichiers et les événements à surveiller

Type d'événement :

select.EPOLLIN Événements lisibles

EPOLLOUT Événement inscriptible.

select.EPOLLERR Événement d'erreur

select.EPOLLHUP Événement de déconnexion du client

epoll.unregister (descripteur de fichier) Détruire le descripteur de fichier

epoll.poll (timeout ) Lorsque le descripteur de fichier change, il sera activement signalé au processus utilisateur sous la forme d'une liste. timeout

est le délai d'expiration, et la valeur par défaut est -1, ce qui signifie attendre que le descripteur de fichier change. S'il est spécifié comme 1

alors le changement du fichier actuel gère toutes les 1 secondes d'epoll, s'il n'y a pas de changement, retournez au vide

EPOLL.FILENO () pour renvoyer le descripteur de fichier de contrôle (RETURN RETURN's RETURN RETURN le descripteur de fichier de contrôle epoll)

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

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

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

5 Exemple : Le client envoie des données et le serveur les recevra Les données sont renvoyées 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!