Python进程池处理并发TCP请求导致客户端卡死的原因与解决方案

在使用Python开发TCP服务端时，很多人会想到用进程池来提升并发处理能力，让多个客户端请求可以同时被处理。但实际开发中经常会遇到这样的问题：客户端发送请求后一直卡住没有响应，服务端似乎也没有报错，这就是典型的客户端卡死问题。下面我们来详细分析原因并给出对应的解决方法。

问题复现：有问题的进程池TCP服务端代码

我们先看一段典型的错误实现代码，这段代码中服务端使用进程池处理TCP连接，很容易触发客户端卡死的问题：

import socket
import multiprocessing

def handle_client(client_socket, client_addr):
    """处理单个客户端请求的函数"""
    print(f"接收到来自 {client_addr} 的连接")
    try:
        # 接收客户端发送的数据
        data = client_socket.recv(1024)
        if data:
            print(f"收到客户端数据: {data.decode('utf-8')}")
            # 向客户端返回响应
            client_socket.sendall(b"Hello from server")
        else:
            print("客户端主动关闭连接")
    except Exception as e:
        print(f"处理客户端请求出错: {e}")
    finally:
        # 关闭客户端套接字
        client_socket.close()

def main():
    # 创建TCP服务端套接字
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口复用，避免程序重启时端口被占用
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    # 绑定地址和端口，这里用127.0.0.1做本地测试
    server_socket.bind(("127.0.0.1", 8888))
    # 开始监听，最大等待连接数为5
    server_socket.listen(5)
    print("服务端启动，监听 127.0.0.1:8888")
    
    # 创建进程池，最大进程数为3
    pool = multiprocessing.Pool(processes=3)
    
    while True:
        # 阻塞等待客户端连接
        client_socket, client_addr = server_socket.accept()
        # 把客户端处理任务提交到进程池
        pool.apply_async(handle_client, args=(client_socket, client_addr))
    
    # 关闭服务端套接字（实际上上面的循环不会结束，这行不会执行）
    server_socket.close()

if __name__ == "__main__":
    main()

我们可以写一个简单的客户端来测试这段代码：

import socket

def test_client():
    # 创建TCP客户端套接字
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接到服务端
    client_socket.connect(("127.0.0.1", 8888))
    # 发送测试数据
    client_socket.sendall(b"Hello from client")
    
    try:
        # 接收服务端响应，这里会卡死
        response = client_socket.recv(1024)
        print(f"收到服务端响应: {response.decode('utf-8')}")
    except Exception as e:
        print(f"接收响应出错: {e}")
    finally:
        client_socket.close()

if __name__ == "__main__":
    test_client()

卡死原因分析

上面的代码运行后，客户端经常会卡在recv调用处没有返回，核心原因有两个：

• 第一个原因是套接字对象的fork继承问题：当使用multiprocessing.Pool提交任务时，子进程是通过fork（类Unix系统）或者spawn（Windows系统）方式创建的。如果是fork方式，子进程会继承父进程的所有文件描述符，包括已经连接的客户端套接字。当父进程的accept获取到客户端套接字后，把套接字对象传给子进程，父进程本身并没有关闭这个套接字的引用，导致套接字的引用计数一直大于0，即使子进程调用了close，只是减少了一次引用，套接字并没有真正关闭，服务端的TCP连接不会进入四次挥手流程，客户端自然收不到服务端的响应，会一直阻塞等待。
• 第二个原因是进程池任务提交的逻辑问题：上面的代码中，父进程在accept之后直接把套接字提交给进程池，但是父进程没有对套接字做任何处理，而且进程池的任务是异步提交的，如果进程池的任务队列满了，或者子进程处理速度慢，父进程会一直循环accept新的连接，而之前的连接处理可能被阻塞，导致客户端请求得不到及时响应。

解决方案

针对上面的问题，我们可以从两个方向修改代码：

方案一：父进程主动关闭套接字引用

在把客户端套接字交给子进程处理后，父进程需要主动关闭自己对这个套接字的引用，这样子进程处理完关闭套接字时，套接字的引用计数会降为0，真正触发TCP连接关闭，客户端就能收到响应了。修改后的服务端代码如下：

import socket
import multiprocessing

def handle_client(client_socket, client_addr):
    """处理单个客户端请求的函数"""
    print(f"接收到来自 {client_addr} 的连接")
    try:
        # 接收客户端发送的数据
        data = client_socket.recv(1024)
        if data:
            print(f"收到客户端数据: {data.decode('utf-8')}")
            # 向客户端返回响应
            client_socket.sendall(b"Hello from server")
        else:
            print("客户端主动关闭连接")
    except Exception as e:
        print(f"处理客户端请求出错: {e}")
    finally:
        # 关闭客户端套接字，此时是子进程自己的引用，关闭后如果没有其他引用，连接会关闭
        client_socket.close()

def main():
    # 创建TCP服务端套接字
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口复用，避免程序重启时端口被占用
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    # 绑定地址和端口，这里用127.0.0.1做本地测试
    server_socket.bind(("127.0.0.1", 8888))
    # 开始监听，最大等待连接数为5
    server_socket.listen(5)
    print("服务端启动，监听 127.0.0.1:8888")
    
    # 创建进程池，最大进程数为3
    pool = multiprocessing.Pool(processes=3)
    
    while True:
        # 阻塞等待客户端连接
        client_socket, client_addr = server_socket.accept()
        # 把客户端处理任务提交到进程池
        pool.apply_async(handle_client, args=(client_socket, client_addr))
        # 父进程主动关闭对客户端套接字的引用，避免引用计数无法归零
        client_socket.close()
    
    # 关闭服务端套接字（实际上上面的循环不会结束，这行不会执行）
    server_socket.close()

if __name__ == "__main__":
    main()

方案二：使用socket的共享方式（针对spawn启动的进程）

如果是Windows系统，或者Python使用spawn方式启动子进程，fork的继承方式不适用，这时候需要把套接字的描述符传递或者重新创建。不过更简单的做法是避免把套接字对象直接传给子进程，而是用其他方式处理，比如使用multiprocessing.reduction来传递套接字，或者在父进程中先接收完数据再交给进程池处理。不过更推荐的是使用concurrent.futures的进程池，它的接口更友好，也能规避部分套接字传递的问题：

import socket
import concurrent.futures

def handle_client(client_socket, client_addr):
    """处理单个客户端请求的函数"""
    print(f"接收到来自 {client_addr} 的连接")
    try:
        # 接收客户端发送的数据
        data = client_socket.recv(1024)
        if data:
            print(f"收到客户端数据: {data.decode('utf-8')}")
            # 向客户端返回响应
            client_socket.sendall(b"Hello from server")
        else:
            print("客户端主动关闭连接")
    except Exception as e:
        print(f"处理客户端请求出错: {e}")
    finally:
        client_socket.close()

def main():
    # 创建TCP服务端套接字
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    server_socket.bind(("127.0.0.1", 8888))
    server_socket.listen(5)
    print("服务端启动，监听 127.0.0.1:8888")
    
    # 使用concurrent.futures的进程池，最大进程数为3
    with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
        while True:
            client_socket, client_addr = server_socket.accept()
            # 提交任务到进程池
            executor.submit(handle_client, client_socket, client_addr)
            # 父进程主动关闭套接字引用
            client_socket.close()

if __name__ == "__main__":
    main()

额外注意事项

• 如果是短连接场景，上面的修改已经足够解决问题；如果是长连接，需要额外处理心跳、超时断开等逻辑，避免进程池被长期占用的连接耗尽。
• 进程池的大小需要根据服务器的CPU核心数和业务场景调整，不是越大越好，过多的进程会导致上下文切换开销增大，反而降低性能。
• 如果处理的是高并发场景，也可以考虑使用IO多路复用（比如select、poll、epoll）结合进程池的方式，避免每个连接都占用一个进程资源。

Python进程池TCP服务端客户端卡死socket套接字并发编程 本作品最后修改时间：2026-05-23 21:16:55