Python套接字压力并发

Question

我需要一个可以处理至少数万个并发套接字连接的Python TCP服务器.我试图在多处理器和多线程模式下测试Python SocketServer包功能,但两者都远远没有达到预期的性能.

首先,我将描述客户端,因为这两种情况都很常见.

client.py

import socket
import sys
import threading
import time


SOCKET_AMOUNT = 10000
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])


def client(ip, port, message):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((ip, port))
    while 1:
        sock.sendall(message)
        time.sleep(1)
    sock.close()


for i in range(SOCKET_AMOUNT):
    msg = "test message"
    client_thread = threading.Thread(target=client, args=(HOST, PORT, msg))
    client_thread.start()

多处理器服务器:

foked_server.py

import os
import SocketServer


class ForkedTCPRequestHandler(SocketServer.BaseRequestHandler):

    def handle(self):
        cur_process = os.getpid()
        print "launching a new socket handler, pid = {}".format(cur_process)
        while 1:
            self.request.recv(4096)


class ForkedTCPServer(SocketServer.ForkingMixIn, SocketServer.TCPServer):
    pass


if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ForkedTCPServer((HOST, PORT), ForkedTCPRequestHandler)
    print "Starting Forked Server"
    server.serve_forever()

多线程服务器:

threaded_server.py

import threading
import SocketServer


class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):

    def handle(self):
        cur_thread = threading.current_thread()
        print "launching a new socket handler, thread = {}".format(cur_thread)
        while 1:
            self.request.recv(4096)


class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass


if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ThreadedTCPServer((HOST, PORT), ForkedTCPRequestHandler)
    print "Starting Threaded Server"
    server.serve_forever()

在第一种情况下,使用forked_server.py,只创建了40个进程,其中大约20个进程突然中断,并出现以下错误:

错误:[Errno 104]由对等方重置连接

在客户端.

螺纹版本更耐用,可容纳超过4000个连接,但最终开始显示

gaierror:[Errno -5]没有与主机名相关的地址

测试是在我的本地机器上进行的,Kubuntu 14.04 x64在内核v3.13.0-32上进行.这些是我为提高系统的一般性能而采取的步骤:

1. 提高文件句柄的内核限制: sysctl -w fs.file-max=10000000
2. 增加连接积压, sysctl -w net.core.netdev_max_backlog = 2500
3. 提高最大连接数, sysctl -w net.core.somaxconn = 250000

所以,问题是:

1. 如果测试正确,我可以依靠这些结果吗？我是所有这些网络/套接字的新手,所以请在我的结论中纠正我.
2. 在重负载系统中,多处理器/多线程方法真的不可行吗？
3. 如果是,我们还有哪些选择？异步方法？Tornado/Twisted/Gevent框架？

Answer 1

socketserver是不会处理近10k连接的任何地方.当前硬件和操作系统上没有线程或分叉服务器.成千上万的线程意味着您花费更多时间进行上下文切换和调度而不是实际工作.现代linux在调度线程和进程方面非常擅长,而且Windows在线程方面相当不错(但是对于进程来说很糟糕),但是它的功能有限.

并且socketserver甚至不尝试高性能.

当然,CPython的GIL会让事情变得更糟.如果你不使用3.2+; 任何线程甚至做了大量的CPU限制工作都会阻塞所有其他线程并阻塞你的I/O. 使用新的GIL,如果您避免使用非平凡的CPU,则不会对问题添加太多内容,但它仍会使上下文切换比原始pthread或Windows线程更昂贵.

那么,是什么做你想要什么？

您需要一个单线程"reactor"来为循环中的事件提供服务并启动处理程序.(在Windows和Solaris上,使用"proactor",一个所有服务于同一事件队列的线程池都有优势,但是因为你在Linux上,所以不要担心.)现代操作系统非常好用多路复用API构建kqueue在BSD/Mac上,epoll在Linux上,/dev/poll在Solaris上,在Windows上构建IOCP,即使在多年前的硬件上也能轻松处理10K连接.

socketserver它不是一个糟糕的反应堆,它只是它没有提供任何好的方法来分派异步工作,只有线程或进程.从理论上讲,你可以构建一个GreenletMixIn(使用greenlet扩展模块)或者CoroutineMixIn(假设你有或者知道如何编写蹦床和调度程序),而不需要太多工作socketserver,这可能不会太重.但是我不确定你socketserver在这一点上获得了多少好处.

并行性可以提供帮助,但只能从主要工作线程中调度任何慢速作业.首先获得10K连接,做最少的工作.然后,如果您要添加的实际工作是I/O绑定(例如,读取文件或向其他服务发出请求),请添加要分派的线程池; 如果你需要添加大量的CPU绑定工作,请添加一个流程池(或者,在某些情况下,甚至是每个流程中的一个).

如果你可以使用Python 3.4,stdlib有一个答案asyncio(并且在PyPI for 3.3上有一个backport,但它本身不可能向后移植到早期版本).

如果不是......好吧,如果你不关心Windows ,你可以selectors在3.4+ 之上自己构建一些东西,select如果你只关心linux,*BSD和Mac,你可以自己编写两个版本的你自己.代码,但这将是很多工作.或者您可以在C中编写核心事件循环(或者只使用现有的类似libev或libuv或libevent)并将其包装在扩展模块中.

但实际上,您可能希望转向第三方库.其中有许多API,具有非常不同的API gevent(它们试图使您的代码看起来像抢占式线程代码,但实际上是在单线程事件循环中运行greenlet)Twisted(基于显式回调和期货,类似于许多现代JavaScript框架).

StackOverflow不是获取特定库建议的好地方,但我可以给你一个大致的建议:查看它们,选择一个API听起来最适合你的应用程序,测试它是否足够好,并且只能回到另一个一个,如果你喜欢的人不能削减它(或者如果你对喜欢的API有误).其中一些库(尤其是球迷gevent,并tornado会告诉你,他们最喜欢的是"最快的",但谁在乎呢？重要的是它们是否足够快和可用于编写你的应用程序.

关闭我的头顶,我会寻找gevent,eventlet,concurrence,cogen,twisted,tornado,monocle,diesel,和circuits.这可能不是一个很好的列表,但如果你把所有这些条款一起谷歌,我敢打赌你会找到一个最新的比较,或一个适当的论坛来询问.