What is the reason why the Python process pool handles concurrent TCP requests and causes the client to get stuck?

The root cause and solution for the Python process pool to process concurrent TCP requests and causes client jamming

This article analyzes the reasons why the client may get stuck when using Python process pool to handle concurrent TCP requests and provides an effective solution.

Problem: The server uses multiprocessing.Pool to create a process pool to process TCP requests, and the client uses ThreadPoolExecutor to send requests concurrently. On macOS system, when the client thread pool max_workers is greater than 1, the client will be stuck; but it runs normally on Ubuntu system. The server code uses pool.apply_async to allocate tasks non-blocking, and there seems to be no blocking problem.

The root cause: The server code passes socket object directly to the child process. Since socket object cannot be shared directly between processes, the child process fails when trying to copy socket object, causing the child process to fail to work properly and block client requests.

Solution: Avoid passing socket objects directly, but pass their file descriptors (file descriptors).

Improved server code:

 import os
import socket
import sys
import time
import threading
from loguru import logger
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures._base import Future
import multiprocessing

default_encoding: str = 'utf-8'

def init_serversocket() -> socket.socket:
    # ... (The code is the same as the original question description) ...

def send_response(clientsocket: socket.socket, addr: tuple, response_body: bytes) -> int:
    # ... (The code is the same as the original question description) ...

def start_request(clientsocket_fd: int, addr: tuple) -> int:
    clientsocket = socket.fromfd(clientsocket_fd, socket.AF_INET, socket.SOCK_STREAM)
    os.close(clientsocket_fd) # Close the original file descriptor to prevent resource leakage try:
        # ... (The code is the same as the original question description) ...
    except Exception as error:
        logger.exception(error)
    Finally:
        clientsocket.close()

def worker_process(clientsocket_fd, addr):
    start_request(clientsocket_fd, addr)

if __name__ == "__main__":
    serversocket = init_serversocket()

    pool = multiprocessing.Pool(processes=16)

    While True:
        try:
            clientsocket, addr = serversocket.accept()
            clientsocket_fd = clientsocket.fileno()
            pool.apply_async(worker_process, (clientsocket_fd, addr))
        except Exception as error:
            logger.exception(error)

    pool.close()
    pool.join()

Improvement instructions:

1. The start_request function now receives clientsocket 's file descriptor clientsocket_fd .
2. The socket.fromfd function rebuilds the socket object based on the file descriptor to ensure that the child process can operate the socket correctly.
3. Add clientsocket.close() in finally block to make sure the socket is closed correctly.
4. The worker_process function handles clientsocket_fd and closes the file descriptor in the child process to avoid resource leakage.

By passing file descriptors instead of socket objects themselves, the problem of inter-process communication is solved, thereby avoiding the problem of client jamming. This method ensures correct handling of TCP connections in a multi-process environment.

The above is the detailed content of What is the reason why the Python process pool handles concurrent TCP requests and causes the client to get stuck?. For more information, please follow other related articles on the PHP Chinese website!