如何提升Python3 socketserver实现的DNS服务器的最大QPS？

我正在开发基于Python3的DNS服务器，使用socketserver模块时遇到了每秒最大查询数（QPS）的性能瓶颈。此前用socket+threading组合实现时QPS仅约5k，换用socketserver后提升到约8k，但和Bind9的5万QPS差距巨大，恳请指点问题所在及优化方向。

Bind9测试数据（2核CPU环境） #

DNS Performance Testing Tool
Version 2.11.2

[Status] Command line: dnsperf -s 127.0.0.1 -d example.com -l 60
[Status] Sending queries (to 127.0.0.1:53)
[Status] Started at: Mon May  8 14:26:55 2023
[Status] Stopping after 60.000000 seconds
[Status] Testing complete (time limit)

Statistics:

Queries sent:         3055286
Queries completed:    3055286 (100.00%)
Queries lost:         0 (0.00%)

Response codes:       NOERROR 3055286 (100.00%)
Average packet size:  request 29, response 45
Run time (s):         60.010743
Queries per second:   50912.317483

Average Latency (s):  0.001872 (min 0.000050, max 0.077585)
Latency StdDev (s):   0.000859

vic@waramik:/home/vic/scripts$ uptime
14:27:58 up 2 days,  4:09,  1 user,  load average: 0.73, 0.29, 0.25

2核CPU下QPS约5万，1分钟负载均值0.73

Python socketserver实现的DNS回显服务器代码 #

import socketserver

class UDPserver(socketserver.BaseRequestHandler):

    def handle(self):
        data, sock = self.request
        sock.sendto(data, self.client_address)

if __name__ == "__main__":
    host = "127.0.0.2"
    port = 53
    addr = (host, port)
    with socketserver.ThreadingUDPServer(addr, UDPserver) as udp:
        print(f'Start to listen on {addr}')
        udp.serve_forever(0.1)

查询响应示例 #

$ dig example.com @127.0.0.2
;; Warning: query response not set

; <<>> DiG 9.18.12-0ubuntu0.22.04.1-Ubuntu <<>> example.com @127.0.0.2
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10796
;; flags: rd ad; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1
;; WARNING: recursion requested but not available

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 12158dbef76fddc9 (echoed)
;; QUESTION SECTION:
;example.com.                   IN      A

;; Query time: 0 msec
;; SERVER: 127.0.0.2#53(127.0.0.2) (UDP)
;; WHEN: Mon May 08 14:24:33 MSK 2023
;; MSG SIZE  rcvd: 52

Python服务器压测数据（同2核CPU环境） #

DNS Performance Testing Tool
Version 2.11.2

[Status] Command line: dnsperf -s 127.0.0.2 -d example.com -l 60
[Status] Sending queries (to 127.0.0.2:53)
[Status] Started at: Mon May  8 14:29:35 2023
[Status] Stopping after 60.000000 seconds
[Status] Testing complete (time limit)

Statistics:

Queries sent:         478089
Queries completed:    478089 (100.00%)
Queries lost:         0 (0.00%)

Response codes:       NOERROR 478089 (100.00%)
Average packet size:  request 29, response 29
Run time (s):         60.024616
Queries per second:   7964.882274

Average Latency (s):  0.012543 (min 0.000420, max 0.082480)
Latency StdDev (s):   0.003576

$ uptime
14:30:49 up 2 days,  4:12,  1 user,  load average: 1.22, 0.56, 0.34

同环境下QPS仅约8k，1分钟负载均值1.22，负载更高

问题分析 #

1. 线程模型开销：ThreadingUDPServer为每个请求创建新线程，线程的创建、销毁和上下文切换带来大量额外开销，而Bind9采用更高效的事件驱动/线程池模型，避免了频繁线程创建的损耗。
2. GIL限制：Python的全局解释器锁（GIL）导致同一时刻只有一个线程执行Python字节码，高频请求下GIL的切换开销被放大，无法真正利用多核CPU并行处理。
3. 框架封装开销：socketserver作为通用框架，提供的抽象层在高频请求场景下会累积额外性能损耗。

优化方向 #

1. 替换线程模型为进程池或事件驱动 #

• 使用ForkingUDPServer：多进程模式绕过GIL限制，每个进程拥有独立解释器和GIL，能真正利用多核CPU，适合无状态的DNS回显场景。
• 异步IO实现：用asyncio或uvloop（高性能asyncio事件循环）构建事件驱动服务器，避免线程/进程切换开销。示例代码：

import asyncio

async def handle_dns_datagram(data, addr, transport):
    transport.sendto(data, addr)

async def main():
    loop = asyncio.get_running_loop()
    transport, _ = await loop.create_datagram_endpoint(
        lambda: asyncio.DatagramProtocol(),
        local_addr=('127.0.0.2', 53)
    )
    # 替换协议的回调方法
    transport._protocol.datagram_received = lambda data, addr: handle_dns_datagram(data, addr, transport)
    await asyncio.Future()  # 保持服务运行

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

2. 直接使用底层socket+IO多路复用 #

避免socketserver的封装开销，用select/epoll实现IO多路复用，直接操作UDP socket：

import socket
import select

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('127.0.0.2', 53))

while True:
    ready, _, _ = select.select([sock], [], [], 0.1)
    if ready:
        data, addr = sock.recvfrom(4096)
        sock.sendto(data, addr)

3. 优化Python运行环境 #

• 改用PyPy：PyPy的JIT编译能大幅提升高频调用场景的执行速度，对简单逻辑的UDP服务器性能提升明显。
• 开启优化模式：运行代码时添加-O参数，去除断言和调试信息，减少运行时开销。

4. 线程池复用（保留线程模型时） #

预先创建固定数量的线程处理请求，避免频繁创建销毁线程的开销，用concurrent.futures.ThreadPoolExecutor结合底层socket：

import socket
from concurrent.futures import ThreadPoolExecutor

def handle_request(sock, data, addr):
    sock.sendto(data, addr)

def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind(('127.0.0.2', 53))
    # 根据CPU核心数调整线程数
    executor = ThreadPoolExecutor(max_workers=4)

    while True:
        data, addr = sock.recvfrom(4096)
        executor.submit(handle_request, sock, data, addr)

if __name__ == "__main__":
    main()

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