对于此I/O受限操作，为什么异步库比线程慢？
问题描述
我正在编写一个python程序，用于枚举站点的域名。例如，‘a.google.com’。
首先，我使用threading模块完成此操作：
import string
import time
import socket
import threading
from threading import Thread
from queue import Queue
'''
enumerate a site's domain name like this:
1-9 a-z + .google.com
1.google.com
2.google.com
.
.
1a.google.com
.
.
zz.google.com
'''
start = time.time()
def create_host(char):
'''
if char is '1-9a-z'
create char like'1,2,3,...,zz'
'''
for i in char:
yield i
for i in create_host(char):
if len(i)>1:
return False
for c in char:
yield c + i
char = string.digits + string.ascii_lowercase
site = '.google.com'
def getaddr():
while True:
url = q.get()
try:
res = socket.getaddrinfo(url,80)
print(url + ":" + res[0][4][0])
except:
pass
q.task_done()
NUM=1000 #thread's num
q=Queue()
for i in range(NUM):
t = Thread(target=getaddr)
t.setDaemon(True)
t.start()
for host in create_host(char):
q.put(host+site)
q.join()
end = time.time()
print(end-start)
'''
used time:
9.448670148849487
'''
后来，我读到一本书，书中说在某些情况下协程比线程快。因此，我重写了代码以使用asyncio：
import asyncio
import string
import time
start = time.time()
def create_host(char):
for i in char:
yield i
for i in create_host(char):
if len(i)>1:
return False
for c in char:
yield c + i
char = string.digits + string.ascii_lowercase
site = '.google.com'
@asyncio.coroutine
def getaddr(loop, url):
try:
res = yield from loop.getaddrinfo(url,80)
print(url + ':' + res[0][4][0])
except:
pass
loop = asyncio.get_event_loop()
coroutines = asyncio.wait([getaddr(loop, i+site) for i in create_host(char)])
loop.run_until_complete(coroutines)
end = time.time()
print(end-start)
'''
time
120.42313003540039
'''
getaddrinfo的asyncio版本为什么这么慢？我是否在某种程度上误用了协同例程？
LINUX
首先，我无法复制与您在我的推荐答案计算机上看到的性能差异几乎一样大的性能差异。我始终看到线程版本大约20-25秒，asyncio版本大约24-34秒。
asyncio变慢了？有几件事促成了这一点。首先，asyncio版本必须按顺序打印，但线程版本不是这样。打印是I/O，所以GIL可以在发生时释放。这意味着可能有两个或更多线程可以完全同时打印，尽管在实践中这种情况可能不会经常发生，并且可能不会对性能产生太大影响。
第二个，也是更重要的是asyncio版本getaddrinfo实际上是just calling socket.getaddrinfo in a ThreadPoolExecutor：
def getaddrinfo(self, host, port, *,
family=0, type=0, proto=0, flags=0):
if self._debug:
return self.run_in_executor(None, self._getaddrinfo_debug,
host, port, family, type, proto, flags)
else:
return self.run_in_executor(None, socket.getaddrinfo,
host, port, family, type, proto, flags)
它对此使用默认值ThreadPoolExecutor，which only has five threads：
# Argument for default thread pool executor creation.
_MAX_WORKERS = 5
对于这个用例，这几乎不是您想要的并行性。要使其行为更像threading版本，您需要将ThreadPoolExecutor与1000个线程一起使用，方法是通过loop.set_default_executor：
loop = asyncio.get_event_loop()
loop.set_default_executor(ThreadPoolExecutor(1000))
coroutines = asyncio.wait([getaddr(loop, i+site) for i in create_host(char)])
loop.run_until_complete(coroutines)
现在，这将使行为更等同于threading，但这里的实际情况是您实际上没有使用异步I/O-您只是在使用具有不同API的threading。因此，您在此最多只能获得与threading示例相同的性能。
threading版本使用的是一个工作进程池，它们共享一个queue.Queue，而asyncio版本为url列表中的每个项目生成一个协程。如果我使asyncio版本使用asyncio.Queue和协程池，除了删除print语句并创建更大的默认执行器之外，我还可以获得两个版本基本上相同的性能。以下是新的asyncio代码：
import asyncio
import string
import time
from concurrent.futures import ThreadPoolExecutor
start = time.time()
def create_host(char):
for i in char:
yield i
for i in create_host(char):
if len(i)>1:
return False
for c in char:
yield c + i
char = string.digits + string.ascii_lowercase
site = '.google.com'
@asyncio.coroutine
def getaddr(loop, q):
while True:
url = yield from q.get()
if not url:
break
try:
res = yield from loop.getaddrinfo(url,80)
except:
pass
@asyncio.coroutine
def load_q(loop, q):
for host in create_host(char):
yield from q.put(host+site)
for _ in range(NUM):
yield from q.put(None)
NUM = 1000
q = asyncio.Queue()
loop = asyncio.get_event_loop()
loop.set_default_executor(ThreadPoolExecutor(NUM))
coros = [asyncio.async(getaddr(loop, q)) for i in range(NUM)]
loop.run_until_complete(load_q(loop, q))
loop.run_until_complete(asyncio.wait(coros))
end = time.time()
print(end-start)
及其输出：
dan@dandesk:~$ python3 threaded_example.py
20.409344911575317
dan@dandesk:~$ python3 asyncio_example.py
20.39924192428589
相关文章