Pythons IO-Multiplex-Epoll

Was ist Epoll?

Was ist Epoll? In der Linux-Netzwerkprogrammierung wird Select seit langem zum Auslösen von Ereignissen verwendet. Im neuen Linux-Kernel gibt es einen Mechanismus zum Ersetzen, nämlich Epoll. Dies gilt natürlich nicht nur für den 2.6-Kernel. Es wurde im 2.5.44-Kernel eingeführt (epoll(4) ist eine neue API, die im Linux-Kernel 2.5.44 eingeführt wurde). gilt unter Linux 2.6 als die leistungsstärkste Multiplex-I/O-Bereitschaftsbenachrichtigungsmethode.

Im Vergleich zu Select besteht der größte Vorteil von Epoll darin, dass die Effizienz nicht beeinträchtigt wird, wenn die Anzahl der abhörenden FDS zunimmt. Denn in der Select-Implementierung im Kernel erfolgt die Verarbeitung durch Abfrage. Je mehr fds abgefragt werden, desto zeitaufwändiger wird es natürlich.

So funktioniert epoll

epoll benachrichtigt auch nur diese bereiten Dateideskriptoren, und wenn wir epoll_wait() aufrufen, um einen fertigen Dateideskriptor zu erhalten, wird nicht der tatsächliche Deskriptor, sondern ein A-Wert zurückgegeben Stellt die Anzahl der fertigen Deskriptoren dar. Sie müssen nur die entsprechende Anzahl von Dateideskriptoren nacheinander aus einem von Epoll angegebenen Array abrufen, wodurch diese Dateibeschreibungen vollständig entfallen während Systemaufrufen.

Eine weitere wesentliche Verbesserung besteht darin, dass Epoll eine ereignisbasierte Bereitschaftsbenachrichtigungsmethode einführt. Bei Select/Poll scannt der Kernel alle überwachten Dateideskriptoren erst, nachdem der Prozess eine bestimmte Methode aufgerufen hat, während epoll einen Dateideskriptor im Voraus über epoll_ctl() registriert. Sobald ein bestimmter Dateideskriptor bereit ist, verwendet der Kernel einen Rückrufmechanismus ähnelt einem Rückruf, um diesen Dateideskriptor schnell zu aktivieren, und wird benachrichtigt, wenn der Prozess epoll_wait() aufruft.

Wie aus dem oben Gesagten ersichtlich ist, ist Epoll eine Verbesserung gegenüber den Select- und Poll-Modellen, die die Leistung der Netzwerkprogrammierung verbessert und in C/S-Architekturen mit großen gleichzeitigen Anforderungen weit verbreitet ist.

epoll in Python

1. Auslösemethode:

Edge-Trigger/horizontaler Trigger, nur anwendbar auf Unix/Linux-Betriebssystem

2

3. Allgemeine Schritte

Erstellen eines Epoll-Objekts – Erstellen eines Epoll-Objekts

Anweisen des Epoll-Objekts, bestimmte Ereignisse zu überwachen bestimmte Sockets – Weisen Sie das Epoll-Objekt an, auf das angegebene Ereignis am angegebenen Socket zu hören.

Fragen Sie das Epoll-Objekt, welche Sockets seit der letzten Abfrage möglicherweise das angegebene Ereignis hatten. – Fragen Sie das Epoll-Objekt seit der letzten Abfrage die Abfrage, welche angegebenen Ereignisse an welchen Sockets aufgetreten sind

Eine Aktion an diesen Sockets ausführen——Einige Operationen an diesen Sockets ausführen

Das Epoll-Objekt anweisen, die Liste der Sockets zu ändern und/oder Zu überwachende Ereignisse – Informieren Sie das Epoll-Objekt, ändern Sie die Socket-Liste und/oder Ereignisse und überwachen Sie

Wiederholen Sie die Schritte 3 bis 5, bis Sie fertig sind – Wiederholen Sie die Schritte 3-5, bis Sie fertig sind

Zerstören Sie das Epoll Objekt – Zerstöre das Epoll-Objekt

4. Verwandte Verwendung

Import Select Import Select Module

epoll = select.epoll() erstellt ein Epoll-Objekt

epoll.register (Dateihandle, Ereignistyp) registriert das zu überwachende Dateihandle und Ereignis

Ereignistyp:

select.EPOLLIN Lesbare Ereignisse

EPOLLOUT Beschreibbar Ereignis

select.EPOLLERR Fehlerereignis

select.EPOLLHUP Client-Trennereignis

epoll.unregister(file handle) Dateihandle zerstören

epoll.poll( Timeout) Wenn sich das Dateihandle ändert, wird es dem Benutzerprozess aktiv in Form einer Liste gemeldet. Timeout

ist das Timeout, und der Standardwert ist -1, was bedeutet, dass gewartet wird, bis sich das Dateihandle ändert . Wenn es als 1

angegeben ist, wird das aktuelle Dateihandle alle 1 Sekunde von epoll geändert. Wenn es keine Änderung gibt, kehren Sie zum leeren

EPOLL.FILENO () zurück Der Steuerdateideskriptor (RETURN RETURN's RETURN RETURN der Epoll-Steuerdateideskriptor)

epoll.modfiy(fineno,event)fineno ist der Dateideskriptor. Ereignis ist der Ereignistyp. Seine Funktion besteht darin, das entsprechende Ereignis zu ändern Dateideskriptor

epoll.fromfd(fileno ) Erstellen Sie ein Epoll-Objekt aus einem angegebenen Dateideskriptor

epoll.close() Schließen Sie den Steuerdateideskriptor des Epoll-Objekts

5 Beispiel: Der Client sendet Daten und der Server empfängt sie. Die Daten werden an den Client zurückgegeben

Servercode

#!/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()

Clientcode:

#!/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()

Das obige ist der detaillierte Inhalt vonPythons IO-Multiplex-Epoll. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!