Python 使用协程与线程时的吞吐量差异
几天前,我问了一个关于如何帮助我设计构造多个HTTP请求的范例的问题 下面是一个场景。我想要一个多生产者、多消费者的系统。我的制作人抓取和刮取一些站点,并将找到的链接添加到队列中。因为我将对多个站点进行爬网,所以我希望有多个生产者/爬网者 消费者/工作者从这个队列中获取信息,向这些链接发出TCP/UDP请求,并将结果保存到我的Django数据库中。我还希望有多个工作人员,因为每个队列项目彼此完全独立 人们建议为此使用一个协同程序库,即Gevent或Eventlet。由于从未使用过协程,我了解到,尽管编程范式类似于线程范式,但只有一个线程正在积极执行,但当阻塞调用发生时(如I/O调用),堆栈在内存中切换,而另一个绿色线程将接管,直到它遇到某种阻塞I/O调用。希望我没弄错吧?以下是我的一篇SO帖子中的代码:Python 使用协程与线程时的吞吐量差异,python,multithreading,coroutine,gevent,Python,Multithreading,Coroutine,Gevent,几天前,我问了一个关于如何帮助我设计构造多个HTTP请求的范例的问题 下面是一个场景。我想要一个多生产者、多消费者的系统。我的制作人抓取和刮取一些站点,并将找到的链接添加到队列中。因为我将对多个站点进行爬网,所以我希望有多个生产者/爬网者 消费者/工作者从这个队列中获取信息,向这些链接发出TCP/UDP请求,并将结果保存到我的Django数据库中。我还希望有多个工作人员,因为每个队列项目彼此完全独立 人们建议为此使用一个协同程序库,即Gevent或Eventlet。由于从未使用过协程,我了解到,
import gevent
from gevent.queue import *
import time
import random
q = JoinableQueue()
workers = []
producers = []
def do_work(wid, value):
gevent.sleep(random.randint(0,2))
print 'Task', value, 'done', wid
def worker(wid):
while True:
item = q.get()
try:
print "Got item %s" % item
do_work(wid, item)
finally:
print "No more items"
q.task_done()
def producer():
while True:
item = random.randint(1, 11)
if item == 10:
print "Signal Received"
return
else:
print "Added item %s" % item
q.put(item)
for i in range(4):
workers.append(gevent.spawn(worker, random.randint(1, 100000)))
# This doesn't work.
for j in range(2):
producers.append(gevent.spawn(producer))
# Uncommenting this makes this script work.
# producer()
q.join()
这很好,因为sleep
调用正在阻止调用,当sleep
事件发生时,另一个绿色线程将接管。这比顺序执行快得多。
如您所见,我的程序中没有任何代码故意将一个线程的执行转移到另一个线程。我看不出这如何适合上面的场景,因为我希望所有线程同时执行
所有这些都可以正常工作,但我觉得使用Gevent/Eventlets实现的吞吐量高于原始顺序运行的程序,但大大低于使用真正的线程实现的吞吐量
如果我使用线程机制重新实现我的程序,那么我的每个生产者和消费者都可以同时工作,而不需要像协程那样交换堆栈
这应该使用线程重新实现吗?我的设计错了吗?我没有看到使用协同程序的真正好处
也许我的概念有点模糊,但这就是我所吸收的。对我的范例和概念的任何帮助或澄清都是非常好的
谢谢当您有很多(绿色)线程时,gevent非常棒。我测试了数千次,效果非常好。您必须确保用于刮取和保存到db的所有库都变为绿色。如果他们使用python的套接字,gevent注入应该可以工作。但是,用C编写的扩展(例如mysqldb)会阻塞,您需要使用绿色等价物
如果您使用gevent,您基本上可以消除队列,为每个任务生成新的(绿色)线程,线程的代码简单到
db.save(web.get(address))
。gevent将在数据库或web块中出现某些库时负责抢占。只要任务放在内存中,它就可以工作。在这种情况下,问题不在于程序速度(即gevent或线程的选择),而在于网络IO吞吐量。这是(应该是)决定程序运行速度的瓶颈
Gevent是一种很好的方法,可以确保这是瓶颈,而不是程序的体系结构
这就是您想要的流程:
import gevent
from gevent.queue import Queue, JoinableQueue
from gevent.monkey import patch_all
patch_all() # Patch urllib2, etc
def worker(work_queue, output_queue):
for work_unit in work_queue:
finished = do_work(work_unit)
output_queue.put(finished)
work_queue.task_done()
def producer(input_queue, work_queue):
for url in input_queue:
url_list = crawl(url)
for work in url_list:
work_queue.put(work)
input_queue.task_done()
def do_work(work):
gevent.sleep(0) # Actually proces link here
return work
def crawl(url):
gevent.sleep(0)
return list(url) # Actually process url here
input = JoinableQueue()
work = JoinableQueue()
output = Queue()
workers = [gevent.spawn(worker, work, output) for i in range(0, 10)]
producers = [gevent.spawn(producer, input, work) for i in range(0, 10)]
list_of_urls = ['foo', 'bar']
for url in list_of_urls:
input.put(url)
# Wait for input to finish processing
input.join()
print 'finished producing'
# Wait for workers to finish processing work
work.join()
print 'finished working'
# We now have output!
print 'output:'
for message in output:
print message
# Or if you'd like, you could use the output as it comes!
您不需要等待输入和工作队列完成,我在这里刚刚演示了这一点
正如你所看到的,我的程序中没有任何代码是故意的
将一个线程的执行转移到另一个线程。我看不见
这是如何符合上述场景的,因为我希望
线程同时执行
有一个操作系统线程,但有几个greenlet。在您的情况下,gevent.sleep()
允许工人并发执行。阻止IO调用,例如urlib2.urlopen(url).read()
如果使用urlib2
patched来处理gevent
(通过调用gevent.monkey.patch_*()
),则执行相同的操作
另请参见,以了解代码如何在单线程环境中并发工作
要比较gevent、线程、多处理之间的吞吐量差异,您可以编写与所有AProach兼容的代码:
#!/usr/bin/env python
concurrency_impl = 'gevent' # single process, single thread
##concurrency_impl = 'threading' # single process, multiple threads
##concurrency_impl = 'multiprocessing' # multiple processes
if concurrency_impl == 'gevent':
import gevent.monkey; gevent.monkey.patch_all()
import logging
import time
import random
from itertools import count, islice
info = logging.info
if concurrency_impl in ['gevent', 'threading']:
from Queue import Queue as JoinableQueue
from threading import Thread
if concurrency_impl == 'multiprocessing':
from multiprocessing import Process as Thread, JoinableQueue
脚本的其余部分对于所有并发实现都是相同的:
def do_work(wid, value):
time.sleep(random.randint(0,2))
info("%d Task %s done" % (wid, value))
def worker(wid, q):
while True:
item = q.get()
try:
info("%d Got item %s" % (wid, item))
do_work(wid, item)
finally:
q.task_done()
info("%d Done item %s" % (wid, item))
def producer(pid, q):
for item in iter(lambda: random.randint(1, 11), 10):
time.sleep(.1) # simulate a green blocking call that yields control
info("%d Added item %s" % (pid, item))
q.put(item)
info("%d Signal Received" % (pid,))
不要在模块级别执行代码将其放入main()
:
为什么不使用多进程?我不知道多线程与多进程的利弊,所以我不知道它是否合适。在Python程序中,如果不借助C扩展(或重型操作系统进程),就没有“真正的线程”(在任何给定的时间只执行一个实际的操作系统线程)这样的东西由于全局解释器锁定,您的制作人无法产生控制权。在生产者完成之前不会有并发。嗨,Sebastian,我已经查看了我的代码,看到我的生产者和消费者同时工作。当阻塞操作发生在我的一个greenlet中时,它将控制权让给其他greenlet。我已经添加了缺少的
monkey\u patch
调用,这样套接字模块也不会阻塞,但我的处理器没有足够的内存。一台普通的电脑有足够的能量,可以同时连接更多的网络和更多的小绿圈,但我的速度不够快。我很困惑,为什么它不使用更多的处理器和更快的工作速度。你能帮我理解吗?我很迷路。谢谢。@IDANG Agarwalla先生:我已经对您在问题中发布的代码发表了评论<代码>生产者不能在其中同时工作。@Mridang Agarwalla:如果您的问题是IO绑定(磁盘、网络),那么无论您的CPU有多快都无关紧要,例如,如果您只能以50MB/s的速度写入磁盘,那么您的CPU可以处理1GB/s也无关紧要。此外,您的程序还可以使用其他有限的资源,例如打开的文件数。如果使用gevent
确保所有阻塞调用
def main():
logging.basicConfig(level=logging.INFO,
format="%(asctime)s %(process)d %(message)s")
q = JoinableQueue()
it = count(1)
producers = [Thread(target=producer, args=(i, q)) for i in islice(it, 2)]
workers = [Thread(target=worker, args=(i, q)) for i in islice(it, 4)]
for t in producers+workers:
t.daemon = True
t.start()
for t in producers: t.join() # put items in the queue
q.join() # wait while it is empty
# exit main thread (daemon workers die at this point)
if __name__=="__main__":
main()