Chiudi socket di ascolto in thread python

Question

Ho riscontrato un problema nel tentativo di apprendere i socket per le comunicazioni di rete. Ho creato un thread semplice che ascolta le connessioni e crea processi per connettere i client, ma il mio problema è che non riesco a far entrare correttamente il thread poiché non ho trovato un modo per cancellare il socket.accept() - call quando voglio lasciare il programma.

Il mio codice è simile a questo;

class ServerThread(threading.Thread): 

    def __init__(self, queue, host, port): 
     threading.Thread.__init__(self) 
     self.queue = queue 
     self.running = True 
     self.hostname = host 
     self.port = port 

    def run(self): 
     self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
     self.socket.bind((self.hostname, self.port)) 
     self.socket.listen(1) 
     while self.running: 
      try: 
       conn, address = self.socket.accept() 
       process = Process(target=server_slave, args=(conn, address, self.queue)) 
       process.daemon = True 
       process.start() 
      except socket.timeout: 
       pass 

    def stop(self): 
     self.running = False 
     self.socket.close() 

Sono riuscito a ottenere il programma di chiudere impostando self.setDaemon(True) e basta uscire dal programma principale, consegnando tutto al grande garbage collector - ma che sembra una cattiva soluzione. Ho anche provato a impostare un timeout per il socket ma questo si traduce nell'ottenere [Errno 35] Resource temporarily unavailable (indipendentemente dal timeout effettivo, anche quando l'ho impostato su anni ...).

Cosa sto sbagliando? Ho progettato il thread in modo stupido o mi sono perso qualcosa nell'accettare le connessioni?

Answer 1

Un modo per chiudere il thread sembra essere quello di creare una connessione al socket, continuando così il thread fino al completamento.

def stop(self): 
    self.running = False 
    socket.socket(socket.AF_INET, 
        socket.SOCK_STREAM).connect((self.hostname, self.port)) 
    self.socket.close() 

Questo funziona, ma si sente ancora come potrebbe non essere ottimale ...

Answer 2

Nella maggior parte dei casi si aprirà un nuovo thread o un processo una volta che una connessione viene accettata. Per chiudere la connessione, interrompere il ciclo while. La garbage collection rimuoverà il thread o il processo ma il join garantirà che nessuno venga lasciato indietro.

Le prese persistenti si chiudono quando l'utente le chiude o scadono. Non persistenti, come le pagine web statiche si chiuderanno dopo aver inviato le informazioni.

Ecco un buon esempio di server socket persistente in Python. Utilizza multiprocessing, il che significa che può essere eseguito su più core per attività legate alla CPU. Più comunemente conosciuto come multithreading.

import socket 
import multiprocessing 

def run(): 
    host = '000.000.000.000' 
    port = 1212 
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 
    sock.bind(('', port)) 
    sock.listen(3) 
    while True: 
     p = multiprocessing.Process(target=worker, args=sock.accept()).start() 
def worker(conn, addr): 
    while True: 
     if data == '': 
      #remote connection closed 
      break 
     if len(dataList) > 2: 
      # do stuff 
      print 'This code is untested' 

run() 

Answer 3

Parzialmente testati soluzione

1. Mettere self.socket.settimeout(0.1) destra prima while
2. Mettere conn.settimeout(None) subito dopo accept