我正在实现一个Python脚本，需要在不到5秒的时间内并行发送1500多个数据包。
简而言之，我需要的是：
def send_pkts(ip):
#craft packet
while True:
#send packet
time.sleep(randint(0,3))
for x in list[:1500]:
send_pkts(x)
time.sleep(randint(1,5))
我尝试过简单的单线程，多线程，多处理和多处理+多线程表单，并遇到以下问题：
我可以用更好的方法来完成这项任务吗？
[1]编辑1：
def send_pkt(x):
#craft pkt
while True:
#send pkt
gevent.sleep(0)
gevent.joinall([gevent.spawn(send_pkt, x) for x in list[:1500]])
[2]编辑2（gevent monkey-patching）：
from gevent import monkey; monkey.patch_all()
jobs = [gevent.spawn(send_pkt, x) for x in list[:1500]]
gevent.wait(jobs)
#for send_pkt(x) check [1]
但是我收到以下错误：＆＃34; ValueError：filedescriptor超出了select（）＆＃34; 的范围。所以我检查了我的系统ulimit（软和硬都是最大值：65536）。 之后，我检查了它与Linux上的 select（）限制有关（最多1024 fds）。请检查：http://man7.org/linux/man-pages/man2/select.2.html（BUGS部分） - 为了解决这个问题，我应该使用 poll（）（http://man7.org/linux/man-pages/man2/poll.2.html）代替。但是使用 poll（）我会回到相同的限制：因为轮询是一种阻止方法＆＃34;。
此致
答案 0 :(得分：1)
在 Python 中使用并行性时，一个好的方法是使用 ThreadPoolExecutor 或 ProcessPoolExecutor 从 https://docs.python.org/3/library/concurrent.futures.html#module-concurrent.futures 根据我的经验，这些效果很好。
可以适应您使用的 threadedPoolExecutor 示例。
import concurrent.futures
import urllib.request
import time
IPs= ['168.212. 226.204',
'168.212. 226.204',
'168.212. 226.204',
'168.212. 226.204',
'168.212. 226.204']
def send_pkt(x):
status = 'Failed'
while True:
#send pkt
time.sleep(10)
status = 'Successful'
break
return status
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
future_to_ip = {executor.submit(send_pkt, ip): ip for ip in IPs}
for future in concurrent.futures.as_completed(future_to_ip):
ip = future_to_ip[future]
try:
data = future.result()
except Exception as exc:
print('%r generated an exception: %s' % (ip, exc))
else:
print('%r send %s' % (url, data))
答案 1 :(得分：0)
您在选项3中的结果：“由于进程过多，我正在运行脚本的VM冻结（当然，正在运行1500个进程）”可能需要进一步调查。我认为，从到目前为止收集的信息来看，这是否可能更好地归因于多处理方法的缺点或VM的局限性。
一种相当简单明了的方法是进行扩展实验：不是让所有发送都来自单个进程，要么让所有发送都来自同一进程，请尝试使用中间值。将两个工作之间的工作负载分成两半（即4、8）的时间。
这样做的同时，最好在Windows上运行xperf或在Linux上运行oprofile之类的工具来记录这些不同的并行性选择是否导致不同类型的瓶颈，因为例如破坏CPU缓存，运行VM内存不足或其他人知道。最简单的说法就是尝试一下。
根据以前对这些类型问题的经验和一般经验法则，我希望当多处理进程的数量小于或等于可用CPU内核数量（在VM本身上）时，可以获得最佳性能。或在管理程序上）。但是，那是假设问题是受CPU限制的。如果在数据包发送过程中发生某些阻塞，并且与其他阻塞操作交错使用，则可以更好地利用CPU时间，那么与#cpu进程相比，性能可能仍会更高。再说一次，直到完成一些性能分析和/或缩放实验，我们才知道。
答案 2 :(得分：0)
您正确地认为python是单线程的，但是将您想要的任务（发送网络数据包）视为IO绑定操作，因此是多线程的理想选择。只要您在编写代码时就牢记异步，那么在数据包传输时，您的主线程不会很忙。
看看异步tcp网络上的python文档-https://docs.python.org/3/library/asyncio-protocol.html#tcp-echo-client。
答案 3 :(得分：0)
如果瓶颈是基于 http（“发送数据包”），那么 GIL 实际上不应该是太大的问题。
如果在 python 中也有计算，那么 GIL 可能会妨碍，正如你所说，基于进程的并行性将是首选。
每个任务不需要一个进程！这似乎是你思维中的疏忽。使用 python 的 Pool 类，您可以轻松创建一组将从队列中接收任务的工作线程。
import multiprocessing
def send_pkts(ip):
...
number_of_workers = 8
with multiprocessing.Pool(number_of_workers) as pool:
pool.map(send_pkts, list[:1500])
您现在正在运行 number_of_workers + 1 个进程（worker + 原始进程）并且 N 个 worker 同时运行 send_pkts 函数。
答案 4 :(得分：0)
阻碍您实现所需性能的主要问题是 send_pkts() 方法。它不仅发送数据包，还制作数据包：
def send_pkts(ip):
#craft packet
while True:
#send packet
time.sleep(randint(0,3))
虽然发送数据包几乎肯定是 I/O 密集型任务，但制作数据包几乎肯定是 CPU 密集型任务。这个方法需要拆分成两个任务：
我编写了一个基本的套接字服务器和一个客户端应用程序，用于制作数据包并将其发送到服务器。这个想法是有一个单独的过程来制作数据包并将它们放入队列中。有一个线程池与数据包制作过程共享队列。这些线程从队列中取出数据包并将它们发送到服务器。他们还将服务器的响应粘贴到另一个共享队列中，但这仅用于我自己的测试，与您尝试执行的操作无关。当线程从队列中获得 None (poison pill) 时退出。
server.py:
import argparse
import socketserver
import time
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--host", type=str, help="bind to host")
parser.add_argument("--port", type=int, help="bind to port")
parser.add_argument("--packet-size", type=int, help="size of packets")
args = parser.parse_args()
HOST, PORT = args.host, args.port
class MyTCPHandler(socketserver.BaseRequestHandler):
def handle(self):
time.sleep(1.5)
data = self.request.recv(args.packet_size)
self.request.sendall(data.upper())
with socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler) as server:
server.serve_forever()
client.py：
import argparse
import logging
import multiprocessing as mp
import os
import queue as q
import socket
import time
from threading import Thread
def get_logger():
logger = logging.getLogger("threading_example")
logger.setLevel(logging.INFO)
fh = logging.FileHandler("client.log")
fmt = '%(asctime)s - %(threadName)s - %(levelname)s - %(message)s'
formatter = logging.Formatter(fmt)
fh.setFormatter(formatter)
logger.addHandler(fh)
return logger
class PacketMaker(mp.Process):
def __init__(self, result_queue, max_packets, packet_size, num_poison_pills, logger):
mp.Process.__init__(self)
self.result_queue = result_queue
self.max_packets = max_packets
self.packet_size = packet_size
self.num_poison_pills = num_poison_pills
self.num_packets_made = 0
self.logger = logger
def run(self):
while True:
if self.num_packets_made >= self.max_packets:
for _ in range(self.num_poison_pills):
self.result_queue.put(None, timeout=1)
self.logger.debug('PacketMaker exiting')
return
self.result_queue.put(os.urandom(self.packet_size), timeout=1)
self.num_packets_made += 1
class PacketSender(Thread):
def __init__(self, task_queue, result_queue, addr, packet_size, logger):
Thread.__init__(self)
self.task_queue = task_queue
self.result_queue = result_queue
self.server_addr = addr
self.packet_size = packet_size
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect(addr)
self.logger = logger
def run(self):
while True:
packet = self.task_queue.get(timeout=1)
if packet is None:
self.logger.debug("PacketSender exiting")
return
try:
self.sock.sendall(packet)
response = self.sock.recv(self.packet_size)
except socket.error:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect(self.server_addr)
self.sock.sendall(packet)
response = self.sock.recv(self.packet_size)
self.result_queue.put(response)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--num-packets', type=int, help='number of packets to send')
parser.add_argument('--packet-size', type=int, help='packet size in bytes')
parser.add_argument('--num-threads', type=int, help='number of threads sending packets')
parser.add_argument('--host', type=str, help='name of host packets will be sent to')
parser.add_argument('--port', type=int, help='port number of host packets will be sent to')
args = parser.parse_args()
logger = get_logger()
logger.info(f"starting script with args {args}")
packets_to_send = mp.Queue(args.num_packets + args.num_threads)
packets_received = q.Queue(args.num_packets)
producers = [PacketMaker(packets_to_send, args.num_packets, args.packet_size, args.num_threads, logger)]
senders = [PacketSender(packets_to_send, packets_received, (args.host, args.port), args.packet_size, logger)
for _ in range(args.num_threads)]
start_time = time.time()
logger.info("starting workers")
for worker in senders + producers:
worker.start()
for worker in senders:
worker.join()
logger.info("workers finished")
end_time = time.time()
print(f"{packets_received.qsize()} packets received in {end_time - start_time} seconds")
run.sh:
#!/usr/bin/env bash
for i in "$@"
do
case $i in
-s=*|--packet-size=*)
packet_size="${i#*=}"
shift
;;
-n=*|--num-packets=*)
num_packets="${i#*=}"
shift
;;
-t=*|--num-threads=*)
num_threads="${i#*=}"
shift
;;
-h=*|--host=*)
host="${i#*=}"
shift
;;
-p=*|--port=*)
port="${i#*=}"
shift
;;
*)
;;
esac
done
python3 server.py --host="${host}" \
--port="${port}" \
--packet-size="${packet_size}" &
server_pid=$!
python3 client.py --packet-size="${packet_size}" \
--num-packets="${num_packets}" \
--num-threads="${num_threads}" \
--host="${host}" \
--port="${port}"
kill "${server_pid}"
$ ./run.sh -s=1024 -n=1500 -t=300 -h=localhost -p=9999
在 4.70330023765564 秒内收到 1500 个数据包
$ ./run.sh -s=1024 -n=1500 -t=1500 -h=localhost -p=9999
在 1.5025699138641357 秒内收到 1500 个数据包
可以通过将 client.py 中的日志级别更改为 DEBUG 来验证此结果。请注意，脚本的完成时间确实比 4.7 秒要长得多。使用 300 个线程时需要大量拆卸，但日志清楚地表明线程在 4.7 秒内完成处理。
对所有性能结果持保留态度。我不知道你在什么系统上运行这个。我将提供我的相关系统统计信息： 2 至强 X5550 @2.67GHz 24MB DDR3 @1333MHz Debian 10 Python 3.7.3
我会通过您的尝试解决问题：
randint(0, 3) 延迟，这几乎保证至少需要 1.5 x num_packets 秒craft packet 部分而不是 send packet经验法则是：I/O 限制 - 使用线程，CPU 限制 - 使用进程