如何用Python实现多端口绑定的TCP服务器？

你可以通过为每个目标端口创建独立的监听套接字，并结合多线程（或异步IO）来实现同时监听多个端口的TCP服务器。下面是两种常用的实现方式：

方式一：多线程实现（同步阻塞） #

这种方式简单直观，每个端口对应一个独立线程，线程内处理该端口的客户端连接与交互：

import socket
import threading

def handle_client(conn, addr):
    """处理单个客户端的请求（示例为echo服务）"""
    print(f"新连接来自 {addr}")
    try:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            print(f"收到来自 {addr} 的数据: {data.decode('utf-8')}")
            conn.sendall(data)  # 回显数据
    finally:
        conn.close()
        print(f"{addr} 连接已关闭")

def start_tcp_server(host, port):
    """启动单个端口的TCP监听服务"""
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socket.bind((host, port))
    server_socket.listen(5)
    print(f"服务器已启动，监听 {host}:{port}")
    
    while True:
        conn, addr = server_socket.accept()
        # 为每个客户端连接启动新线程处理（也可以用线程池优化）
        client_thread = threading.Thread(target=handle_client, args=(conn, addr))
        client_thread.daemon = True
        client_thread.start()

if __name__ == "__main__":
    # 定义需要监听的端口列表
    listen_ports = [2000, 3000]
    host = "0.0.0.0"  # 监听所有网卡
    
    # 为每个端口启动独立的监听线程
    for port in listen_ports:
        server_thread = threading.Thread(target=start_tcp_server, args=(host, port))
        server_thread.daemon = True
        server_thread.start()
    
    # 保持主程序运行
    while True:
        input("按回车退出...\n")
        break

关键说明： #

• start_tcp_server 函数负责初始化单个端口的监听套接字，绑定、监听后进入循环接受客户端连接
• 每个客户端连接会启动新线程调用 handle_client 处理，避免阻塞当前端口的监听
• SO_REUSEADDR 选项用于快速重启服务器时避免端口占用问题

方式二：异步IO实现（asyncio） #

如果需要更高的并发性能，推荐使用Python的asyncio库实现异步非阻塞的多端口TCP服务器：

import asyncio

async def handle_client(reader, writer):
    """异步处理客户端请求"""
    addr = writer.get_extra_info('peername')
    print(f"新连接来自 {addr}")
    
    while True:
        data = await reader.read(1024)
        if not data:
            break
        message = data.decode('utf-8')
        print(f"收到来自 {addr} 的数据: {message}")
        writer.write(data)
        await writer.drain()
    
    print(f"{addr} 连接已关闭")
    writer.close()
    await writer.wait_closed()

async def start_tcp_server(host, port):
    """启动单个端口的异步TCP服务"""
    server = await asyncio.start_server(handle_client, host, port)
    addr = server.sockets[0].getsockname()
    print(f"异步服务器已启动，监听 {addr}")
    
    async with server:
        await server.serve_forever()

async def main():
    # 定义需要监听的端口列表
    listen_ports = [2000, 3000]
    host = "0.0.0.0"
    
    # 同时启动多个端口的服务
    tasks = [start_tcp_server(host, port) for port in listen_ports]
    await asyncio.gather(*tasks)

if __name__ == "__main__":
    asyncio.run(main())

关键说明： #

• 异步模式下，单个线程即可处理多个端口的大量客户端连接，资源占用更低
• asyncio.start_server 负责创建异步监听服务，handle_client 协程处理客户端交互
• 通过asyncio.gather同时运行多个端口的监听任务

你可以根据实际需求选择合适的实现方式，若业务逻辑简单、并发量不大，多线程方案足够；若追求高性能和低资源消耗，异步IO是更好的选择。

内容的提问来源于stack exchange，提问作者gari