Comment puis-je abandonner une socket.Recvfrom () d'un autre fil à Python?

Implémentez une commande Quitter sur les sockets de serveur et de client. Devrait fonctionner quelque chose comme ceci: xxx

Un bon moyen de gérer ce type d'interruption asynchrone est l'ancien tour de pipe C. Vous pouvez créer un tuyau et utiliser SELECT CODE> / Sondage code> sur la prise et la conduite: maintenant lorsque vous souhaitez interrompre le récepteur, vous pouvez simplement envoyer un caractère au tuyau.

• Avantages:
  • peut fonctionner à la fois pour UDP et TCP LI>
  • est protocole agnostique li> ul> li>
  • inconvénients:
    • Select / Sondage sur les tuyaux ne sont pas disponibles sous Windows, dans ce cas, vous devez le remplacer par une autre prise UDP utilisée comme notification tuyau em> li> li> ul> li> ul>

      point de départ h2>

      interruptable_socket.py code> p> xxx pré>

      une suite de test: p> test_interruptable_socket.py code> p> xxx pré>

      évolution h2>

      Ce code n'est qu'un point de départ. Pour le rendre plus générique, je vois que nous devrions résoudre les problèmes suivants: P>

      1. interface forte>: retour message vide dans l'affaire Interrupt n'est pas une bonne affaire, vaut mieux utiliser une exception pour le gérer li>
      2. Généralisation forte>: nous devrions avoir juste une fonction à appeler avant socket.recv () code>, étendre l'interruption à d'autres recv code> Les méthodes deviennent très simples li>
      3. portabilité forte>: Pour faire un port simple à Windows, nous devrions isoler la notification ASYNC dans un objet de choisir la bonne implémentation de notre système d'exploitation LI> ol>

         Tout d'abord, nous modifions test_interrupt_async () code> Pour vérifier l'exception à la place Message vide: p> xxx pré>

         après cela, nous pouvons remplacer Retour '' ' code> par Soulevez l'interrupteXception code> et les tests passent à nouveau. p>

         La version pratiquée peut être la suivante: p>

         interruptible_socket.py code> p>

         import os
         import socket
         import select
         
         
         class InterruptException(Exception):
             pass
         
         
         class InterruptableUdpSocketReceiver(object):
             def __init__(self, host, port):
                 self._host = host
                 self._port = port
                 self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                 self._async_interrupt = AsycInterrupt(self._socket)
         
             def bind(self):
                 self._socket.bind((self._host, self._port))
         
             def recv(self, buffersize, flags=0):
                 self._async_interrupt.wait_for_receive()
                 return self._socket.recv(buffersize, flags)
         
             def interrupt(self):
                 self._async_interrupt.interrupt()
         
         
         class AsycInterrupt(object):
             def __init__(self, descriptor):
                 self._read, self._write = os.pipe()
                 self._interrupted = False
                 self._descriptor = descriptor
         
             def interrupt(self):
                 self._interrupted = True
                 self._notify()
         
             def wait_for_receive(self):
                 if self._interrupted:
                     raise RuntimeError("Cannot be reused")
                 read, _w, errors = select.select([self._read, self._descriptor], [], [self._descriptor])
                 if self._descriptor not in read:
                     raise InterruptException
         
             def _notify(self):
                 os.write(self._write, "I".encode())