tutoriel python, sélection du module, introduction

Introduction

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

méthode de sélection

est également fournie. Le processus spécifie quels descripteurs de fichiers le noyau écoute (jusqu'à 1024 fds) et quels événements, lorsqu'aucun événement de descripteur de fichier ne 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 : attendre d'être prêt à écrire

xlist : attendre 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 répond à 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, nous pouvons voir que nous devons continuellement appeler select , Cela signifie :

　1 Lorsqu'il y a trop de descripteurs de fichiers, il faudra beaucoup de temps pour copier les descripteurs de fichiers entre l'espace utilisateur et l'espace noyau

　2 Lorsqu'il y a trop de descripteurs de fichiers, le le noyau parcourra les descripteurs de fichiers est également une perte de temps

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

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

Méthode epoll :

epoll a très bien amélioré la sélection :

　1. La solution d'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. Fermez le descripteur de fichier de l'objet epoll

.

epoll.closed

Vrai si l'objet epoll est fermé. Vérifiez si l'objet epoll est fermé

epoll.fileno().

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

epoll.fromfd(fd)

Créer 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. à l'objet epoll Enregistrez fd et les événements correspondants dans

epoll.modify(fd, eventmask)

Modifiez un descripteur de fichier enregistré. fd

epoll.unregister(fd)

Supprimez un descripteur de fichier enregistré de l'objet epoll

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 symbole d'état lisible est 1

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

EPOLLPRI Données urgentes pour lecture

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

EPOLLHUP Un raccrochage s'est produit. sur l'assoc. fd Hang status

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!