Python 为什么此套接字连接只允许1个发送和接收？

背景
我有一个简单的套接字服务器设置，我试图允许同时连接和回显数据。客户端启动几个线程，每个线程都与服务器建立自己的连接。这对于socket.send（）调用很有效，但所有后续调用都会导致“对等方重置连接”或“管道断开”。请注意，我没有找到切换重置和断开管道的更改。我一直在这里寻找解决方案，但恐怕我不知道该寻找什么

我是否以错误的方式进行此操作，或者我是否忽略了设置中的某些内容

服务器

import SocketServer

class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        self.data = self.request.recv(1024).strip()
        print "{} wrote: {}\n".format(self.client_address[0], self.data)
        self.request.send(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
    server.serve_forever()

import socket
import sys
import threading
import time

HOST, PORT = "localhost", 9999
def create_client():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        cur_thread = threading.current_thread()
        sock.connect((HOST, PORT))
        for x in range(55):
            msg = "{}: {}\n".format(cur_thread.name, str(x))
            # Connect to server and send data
            print cur_thread.name + ": sending message\n"
            sock.send(msg)
            # Receive data from the server and shut down
            received = sock.recv(2048)
            print "RX:" + received
    finally:
        cur_thread = threading.current_thread()
        response = "{}: Closing!\n".format(cur_thread.name)
        print response
        sock.close()

if __name__ == "__main__":
    print "testing single thread"
    #create_client()
    print "starting threads"
    client_1 = threading.Thread(target=create_client)
    client_1.daemon = True
    client_1.start()
    client_2 = threading.Thread(target=create_client)
    client_2.daemon = True
    client_2.start()

    time.sleep(20)

客户端

import SocketServer

class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        self.data = self.request.recv(1024).strip()
        print "{} wrote: {}\n".format(self.client_address[0], self.data)
        self.request.send(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
    server.serve_forever()

import socket
import sys
import threading
import time

HOST, PORT = "localhost", 9999
def create_client():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        cur_thread = threading.current_thread()
        sock.connect((HOST, PORT))
        for x in range(55):
            msg = "{}: {}\n".format(cur_thread.name, str(x))
            # Connect to server and send data
            print cur_thread.name + ": sending message\n"
            sock.send(msg)
            # Receive data from the server and shut down
            received = sock.recv(2048)
            print "RX:" + received
    finally:
        cur_thread = threading.current_thread()
        response = "{}: Closing!\n".format(cur_thread.name)
        print response
        sock.close()

if __name__ == "__main__":
    print "testing single thread"
    #create_client()
    print "starting threads"
    client_1 = threading.Thread(target=create_client)
    client_1.daemon = True
    client_1.start()
    client_2 = threading.Thread(target=create_client)
    client_2.daemon = True
    client_2.start()

    time.sleep(20)

---

从

handle

返回时，插座关闭。仅当

self.data=''

时，使用while循环并从

句柄返回<当客户端关闭连接时，code>recv

返回零字节。在测试返回值之前，也不要

strip（）。最后，使用
threadingcpserver
，否则服务器一次只能处理一个连接

例如：

import SocketServer

class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        while True:
            self.data = self.request.recv(1024)
            if self.data == '':
                break
            self.data = self.data.strip()
            print "{} wrote: {}\n".format(self.client_address[0], self.data)
            self.request.send(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
    server.serve_forever()

另请注意，
send（）
不能保证发送所有字节的消息，因此请使用
sendall（）
或检查返回值
recv（）
也可能很棘手。TCP/IP是一种流协议，没有消息边界的概念，因此由您实现一个协议来检查您是否收到了完整的消息。可以发送10000字节，但接收的字节少于10000字节，需要多次接收才能获得整个消息。也可以在一次接收中同时进行两次发送和接收，甚至一次发送的全部内容和另一次发送的部分内容。例如，对于一个简单的协议，只需缓冲所有接收，直到消息中出现
\n
即可。
太好了。谢谢你的提示。这是我第一次使用socketserver类，我并没有完全理解句柄在调用之外做了什么。我最初的测试实际上是使用ThreadingCpserver，但为了确保简单（发布的）服务器工作，我切换到了单个线程。再次感谢。