Python套接字压力并发-Java 学习之路

我需要一个可以处理至少数万个并发套接字连接的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上进行 . 这些是我为提高系统的一般性能而采取的步骤：

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

所以，问题是：

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

2 回答

1

socketserver 不会处理接近10k连接的任何地方 . 当前硬件和操作系统上没有线程或分叉服务器，它可以做什么限制 .

并且 socketserver 甚至没有尝试高性能 .

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

所以你想要什么？

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

socketserver isn 't a terrible reactor, it'只是它没有提供任何好方法来分派异步工作，只提供线程或进程 . 理论上，您可以构建一个 GreenletMixIn （带有 greenlet 扩展模块）或 CoroutineMixIn （假设您拥有或知道如何编写蹦床和调度程序），而无需在 socketserver 之上进行太多工作，这可能不会太重 - 重量 . 但那时我已经离开了 socketserver .

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

如果你可以使用Python 3.4，stdlib在asyncio中有一个答案（并且's a backport on PyPI for 3.3, but it' s本身不可能向后移植到早期版本） .

如果不是......好吧，如果你不关心Windows，你可以自己在selectors上 Build 一些东西，如果你只关心linux，* BSD和Mac，你可以在2.6中编写select并且愿意写两个版本的你代码，但这将是很多工作 . 或者您可以在C中编写核心事件循环（或者只使用现有的循环，如 libev 或 libuv 或 libevent ）并将其包装在扩展模块中 .

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

StackOverflow不是't a good place to get recommendations for specific libraries, but I can give you a general recommendation: Look them over, pick the one whose API sounds best for your application, test whether it'如果您喜欢的那个不能削减它（或者如果您对喜欢API的结果是错误的话），那么它就会回归到另一个 . 其中一些图书馆的粉丝（特别是 gevent 和 tornado 会告诉你他们最喜欢的是"fastest"，但是谁在乎呢？重要的是他们是否足够快且可以用来编写你的应用程序 .

在我的头顶，我会搜索 gevent ， eventlet ， concurrence ， cogen ， twisted ， tornado ， monocle ， diesel 和 circuits . 那可能不会打赌你会找到一个最新的比较，或者一个适当的论坛来询问 .

回复于 2024-04-29T20:41:02+08:00

This guy似乎有一个非常好的解决方案，使用 threading 和 subprocess .

#!/usr/bin/env python
# ssl_load.py - Corey Goldberg - 2008

import httplib
from threading import Thread

threads = 250
host = '192.168.1.14'
file = '/foo.html'

def main():
    for i in range(threads):
        agent = Agent()
        agent.start()

class Agent(Thread):
    def __init__(self):
        Thread.__init__(self)

    def run(self):
        while True:
            conn = httplib.HTTPSConnection(host)
            conn.request('GET', file)
            resp = conn.getresponse()

if __name__ == '__main__':
    main()

由于Windows XP的限制，允许他每个进程最多拥有250个线程 . 这是考虑到他的硬件相当于今天的标准 . 通过将此脚本作为多个进程运行，他能够达到最大15k线程，如下所示：

#!/usr/bin/env python

import subprocess
processes = 60
for i in range(processes):
    subprocess.Popen('python ssl_load.py')

希望这可以帮助你！

回复于 2024-04-29T20:41:02+08:00

Python套接字压力并发

2 回答

相关问题