对于这个 I/O 密集型操作，为什么 asyncio 库比线程慢？

我正在编写一个 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
'''

为什么是asyncio的版本getaddrinfo这么慢吗？我是否以某种方式滥用了协程？

首先，我无法重现与您在我的 Linux 机器上看到的性能差异几乎一样大的性能差异。我一直看到线程版本大约需要 20-25 秒，而线程版本大约需要 24-34 秒。asyncio版本。

现在，为什么是asyncio慢点？有几件事促成了这一点。首先，asyncio版本必须按顺序打印，但线程版本则不需要。打印是 I/O，因此可以在打印时释放 GIL。这意味着两个或更多线程可能会同时打印，尽管实际上这种情况可能不会经常发生，并且可能不会对性能产生太大影响。

其次，也是更重要的一点是，the asyncio的版本getaddrinfo实际上是只是打电话socket.getaddrinfo in a ThreadPoolExecutor https://hg.python.org/cpython/file/6d91c4f40ba1/Lib/asyncio/base_events.py#l461:

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为了这，只有五个线程 https://hg.python.org/cpython/file/6d91c4f40ba1/Lib/asyncio/base_events.py#l40*:

# 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 - 你只是使用threading使用不同的 API。所以你在这里能做的最好的就是与threading例子。

最后，您并没有在每个示例中真正运行等效的代码 -threading版本正在使用一个工作池，它们共享一个queue.Queue，而asyncioversion 正在为 url 列表中的每个项目生成一个协程。如果我做asyncio版本使用asyncio.Queue和协程池，除了删除打印语句和创建更大的默认执行器之外，我在两个版本中获得了基本相同的性能。这是新的asyncio code:

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

但请注意，由于网络原因，存在一些变化。两者有时都会比这慢几秒钟。

* 注意，在Python 3.8及以上版本中，默认ThreadPoolExecutor创造min(32, os.get_cpu_count() + 4)线程。根据您的机器有多少个核心，这可能会导致创建足够的线程以提高性能asyncio为了更紧密地匹配threading例子。你必须测试一下才能看到。