在python线程中关闭监听套接字

Question

我在尝试了解用于网络通信的套接字时遇到问题。我制作了一个简单的线程来监听连接并为连接客户端创建进程，但我的问题是我无法让线程正确加入，因为我还没有找到取消 socket.accept() 调用的方法当我想退出程序时。

我的代码是这样的；

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()

我已经设法通过设置self.setDaemon(True) 并退出主程序来关闭程序，将所有内容交给伟大的垃圾收集器——但这似乎是一个糟糕的解决方案。我也尝试为套接字设置超时，但这会导致得到[Errno 35] Resource temporarily unavailable（不管实际超时，即使我将它设置为年......）。

我做错了什么？我是否以愚蠢的方式设计了线程，或者我错过了接受连接的一些内容？

Answer 1

最好的方法是使用一个与连接线程无关的监听线程，并给它一个合理的超时时间。超时时，检查该线程是否应该关闭，如果没有，则再次循环并返回侦听。

    def tcp_listen_handle(self, port=23, connects=5, timeout=2):
        """This is running in its own thread."""
        sock = socket.socket()
        sock.settimeout(timeout)
        sock.bind(('', port))
        sock.listen(connects)  # We accept more than one connection.
        while self.keep_running_the_listening_thread():
            connection = None
            addr = None
            try:
                connection, addr = sock.accept()
                print("Socket Connected: %s" % str(addr))
                # makes a thread deals with that stuff. We only do listening.
                self.handle_tcp_connection_in_another_thread(connection, addr)
            except socket.timeout:
                pass
            except OSError:
                # Some other error.
                print("Socket was killed: %s" % str(addr))
                if connection is not None:
                    connection.close()
        sock.close()

唯一要做的就是监听，超时，检查它是否应该在超时期间死掉，然后返回监听。一般的经验法则是线程应该检查它们是否应该死亡并尽可能快地尝试自己完成。如果您不想在线程解除阻塞和检查之前等待 2 秒超时等待。您可以自己连接。

Answer 2

允许退出程序的肮脏解决方案是使用os._exit(0)。

def stop(self):
    self.socket.close()
    os._exit(0)

请注意，sys.exit 在尝试干净退出/释放资源时不起作用/阻塞。但是os._exit 是最低级别的方法，它可以正常工作，而其他任何方法都不起作用。

操作系统本身会释放资源（在任何现代系统上），就像在 C 程序中执行 exit 时一样。

Answer 3

部分测试解决方案

1. 将self.socket.settimeout(0.1) 放在while 之前
2. 将conn.settimeout(None) 放在accept 之后

Answer 4

在大多数情况下，一旦连接被接受，您将打开一个新线程或进程。要关闭连接，请中断 while 循环。垃圾收集将删除线程或进程，但加入将确保没有留下任何东西。

持久性套接字在用户关闭它们或它们超时时关闭。非持久性（例如静态网页）会在发送信息后关闭。

这是 Python 中持久套接字服务器的一个很好的示例。它使用多处理，这意味着它可以跨多个内核运行以执行受 CPU 限制的任务。更常见的是多线程。

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 5

让线程关闭的一种方法似乎是与套接字建立连接，从而使线程继续完成。

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

这可行，但仍然感觉它可能不是最佳的......