Exemple de tutoriel du module select en python

Le module select de Python se concentre sur le multiplexage d'E/S et fournit trois méthodes : select poll et epoll (ces deux derniers sont disponibles sous Linux, Windows ne prend en charge que select) et la méthode kqueue (freeBSD). système)

méthode de sélection

Le processus spécifie quels descripteurs de fichiers le noyau écoute (jusqu'à 1024 fds) et quels événements, lorsqu'il n'y a aucun événement de descripteur de fichier, se produit , le processus est bloqué ; lorsqu'un ou plusieurs événements de descripteur de fichier se produisent, le processus est réveillé.

Lorsque nous appelons select() :

1. Passage du contexte à l'état du noyau

2. Copiez fd de l'espace utilisateur vers l'espace noyau

3. Le noyau parcourt tous les fds pour voir si l'événement correspondant se produit

4. S'il ne se produit pas, le processus est bloqué. Lorsque le pilote de périphérique génère une interruption ou un délai d'attente, le processus est réveillé et parcouru à nouveau <.>

5. Renvoie le fd parcouru

6. Copiez le fd de l'espace noyau vers l'espace utilisateur

fd:file descriptor file descriptor

fd_r_list, fd_w_list, fd_e_list = select.select(rlist, wlist, xlist, [timeout])

Paramètres : accepte quatre paramètres (les trois premiers sont obligatoires)

rlist : attendez d'être prêt à lire

wlist : attendez d'être prêt à écrire

xlist : attendez une « condition exceptionnelle »

timeout : délai d'expiration

Valeur de retour : trois listes

La méthode select est utilisée pour surveiller les descripteurs de fichiers (lorsque les conditions du descripteur de fichier ne sont pas remplies, select bloquera Lorsque l'état d'un descripteur de fichier change, trois listes seront renvoyées

1. Lorsque le fd). dans la séquence du paramètre 1 remplit la condition "lisible", obtenez le fd modifié et ajoutez-le à la fd_r_list

2. Lorsque la séquence du paramètre 2 contient fd, alors tous les fd de la séquence seront fd est ajouté à fd_w_list

3. Lorsqu'une erreur se produit dans le fd dans la séquence du paramètre 3, le fd avec l'erreur sera ajouté à fd_e_list

4. Lorsque le délai d'attente est vide, sélectionnez bloquera jusqu'à ce que le handle surveillé change

Lorsque le délai d'attente = n (entier positif), alors s'il n'y a aucun changement dans le handle surveillé, select bloquera pendant n secondes puis renverra trois listes nulles, si le. changements de handle surveillés, il sera exécuté directement.

Exemple :

Utilisez select pour implémenter un serveur simultané

import socket
import select
 
s = socket.socket()
s.bind(('127.0.0.1',8888))
s.listen(5)
r_list = [s,]
num = 0
while True:
 rl, wl, error = select.select(r_list,[],[],10)
 num+=1
 print('counts is %s'%num)
 print("rl's length is %s"%len(rl))
 for fd in rl:
  if fd == s:
   conn, addr = fd.accept()
   r_list.append(conn)
   msg = conn.recv(200)
   conn.sendall(('first----%s'%conn.fileno()).encode())
  else:
   try:
    msg = fd.recv(200)
    fd.sendall('second'.encode())
   except ConnectionAbortedError:
    r_list.remove(fd)
 
s.close()

import socket
 
flag = 1
s = socket.socket()
s.connect(('127.0.0.1',8888))
while flag:
 input_msg = input('input>>>')
 if input_msg == '0':
  break
 s.sendall(input_msg.encode())
 msg = s.recv(1024)
 print(msg.decode())
 
s.close()

Côté serveur, on voit qu'il faut continuer à appeler select, ce qui veut dire :

　1 Lorsqu'il y a trop de descripteurs de fichiers, les descripteurs de fichiers sont copiés entre l'espace utilisateur et l'espace noyau. consommer

　2 Lorsqu'il y a trop de descripteurs de fichiers, la traversée des descripteurs de fichiers par le noyau est également une perte de temps

　3 Select ne prend en charge qu'un maximum de 1024 descripteurs de fichiers

poll Ce n'est pas très différent de select et ne sera pas présenté dans cet article

méthode epoll :

epoll est une bonne amélioration sur select :

1. La solution de epoll est dans la fonction epoll_ctl. Chaque fois qu'un nouvel événement est enregistré sur le handle epoll, tous les fds seront copiés dans le noyau au lieu de copies répétées pendant epoll_wait. epoll garantit que chaque fd ne sera copié qu'une seule fois pendant tout le processus.

2. epoll parcourra le fd spécifié pendant epoll_ctl (ce temps est essentiel) et spécifiera une fonction de rappel pour chaque fd. Lorsque l'appareil est prêt et réveille les serveurs dans la file d'attente, cette fonction de rappel le fera. être appelé, et cette fonction de rappel ajoutera le fd prêt à une liste chaînée prête. Le travail de epoll_wait est en fait de vérifier s'il y a un fd prêt dans cette liste prête

3. epoll n'a aucune restriction supplémentaire sur les descripteurs de fichiers

select . epoll(sizehint=-1, flags=0) Créer un objet epoll

epoll.close()

Fermez le descripteur de fichier de contrôle de l'objet epoll. Objet epoll Descripteur de fichier

epoll.closed

Vrai si l'objet epoll est fermé. Détecte si l'objet epoll est fermé

<. 🎜> epoll.fileno()

Renvoie le numéro de descripteur de fichier du contrôle fd. Renvoie le descripteur de fichier de l'objet epoll

epoll.fromfd(fd)<. 🎜>

Créez un objet epoll à partir d'un descripteur de fichier donné. Créez un objet epoll basé sur le fd spécifié

epoll.register(fd[, eventmask])

Enregistrez un descripteur fd avec l'objet epoll. Enregistrez fd et les événements correspondants dans l'objet epoll

epoll.modify(fd, eventmask)

Modifiez un fichier enregistré. descripteur. Modifier les événements fd

epoll.unregister(fd)

Supprimer un descripteur de fichier enregistré de l'objet epoll.Unregister

epoll.poll(timeout=-1, maxevents=-1)

Attendez le délai d'attente des événements en secondes (float) jusqu'à ce que l'événement fd enregistré se produise, et un dict sera renvoyé au format : {(fd1 ,event1),(fd2,event2),…(fdn,eventn)}

Événement :

EPOLLIN Disponible en lecture Le statut lisible le symbole est 1

EPOLLOUT Disponible pour l'écriture Le code d'état inscriptible est 4

EPOLLPRI Données urgentes pour la lecture

EPOLLERR Une condition d'erreur s'est produite sur l'assoc. Le code d'état d'erreur est. 8

EPOLLHUP Le raccrochage s'est produit sur l'état de raccrochage assoc fd

EPOLLET Set Edge Trigger behavior, the default is Level Trigger behavior 默认为水平触发，设置该事件后则边缘触发

EPOLLONESHOT Set one-shot behavior. After one event is pulled out, the fd is internally disabled

EPOLLRDNORM Equivalent to EPOLLIN

EPOLLRDBAND Priority data band can be read.

EPOLLWRNORM Equivalent to EPOLLOUT

EPOLLWRBAND Priority data may be written.

EPOLLMSG Ignored.

水平触发和边缘触发：

Level_triggered(水平触发，有时也称条件触发)：当被监控的文件描述符上有可读写事件发生时，epoll.poll()会通知处理程序去读写。如果这次没有把数据一次性全部读写完(如读写缓冲区太小)，那么下次调用 epoll.poll()时，它还会通知你在上没读写完的文件描述符上继续读写，当然如果你一直不去读写，它会一直通知你！！！如果系统中有大量你不需要读写的就绪文件描述符，而它们每次都会返回，这样会大大降低处理程序检索自己关心的就绪文件描述符的效率！！！ 优点很明显：稳定可靠

Edge_triggered(边缘触发，有时也称状态触发)：当被监控的文件描述符上有可读写事件发生时，epoll.poll()会通知处理程序去读写。如果这次没有把数据全部读写完(如读写缓冲区太小)，那么下次调用epoll.poll()时，它不会通知你，也就是它只会通知你一次，直到该文件描述符上出现第二次可读写事件才会通知你！！！这种模式比水平触发效率高，系统不会充斥大量你不关心的就绪文件描述符！！！缺点：某些条件下不可靠

epoll实例：

import socket
import select
 
s = socket.socket()
s.bind(('127.0.0.1',8888))
s.listen(5)
epoll_obj = select.epoll()
epoll_obj.register(s,select.EPOLLIN)
connections = {}
while True:
 events = epoll_obj.poll()
 for fd, event in events:
  print(fd,event)
  if fd == s.fileno():
   conn, addr = s.accept()
   connections[conn.fileno()] = conn
   epoll_obj.register(conn,select.EPOLLIN)
   msg = conn.recv(200)
   conn.sendall('ok'.encode())
  else:
   try:
    fd_obj = connections[fd]
    msg = fd_obj.recv(200)
    fd_obj.sendall('ok'.encode())
   except BrokenPipeError:
    epoll_obj.unregister(fd)
    connections[fd].close()
    del connections[fd]
 
s.close()
epoll_obj.close()

import socket
 
flag = 1
s = socket.socket()
s.connect(('127.0.0.1',8888))
while flag:
 input_msg = input('input>>>')
 if input_msg == '0':
  break
 s.sendall(input_msg.encode())
 msg = s.recv(1024)
 print(msg.decode())
 
s.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!