python - 解决 Hettinger 示例的异步三重奏方法

Question

Raymond Hettinger给了a talk on concurrency在 python 中，其中一个示例如下所示:

import urllib.request

sites = [
    'https://www.yahoo.com/',
    'http://www.cnn.com',
    'http://www.python.org',
    'http://www.jython.org',
    'http://www.pypy.org',
    'http://www.perl.org',
    'http://www.cisco.com',
    'http://www.facebook.com',
    'http://www.twitter.com',
    'http://www.macrumors.com/',
    'http://arstechnica.com/',
    'http://www.reuters.com/',
    'http://abcnews.go.com/',
    'http://www.cnbc.com/',
]

for url in sites:
    with urllib.request.urlopen(url) as u:
        page = u.read()
        print(url, len(page))

基本上我们会追踪这些链接并打印接收到的字节数，运行大约需要 20 秒。

今天我找到了trio具有非常友好的 api 的库。但是，当我尝试将它与这个相当基本的示例一起使用时，我却做错了。

第一次尝试(运行大约相同的 20 秒):

import urllib.request
import trio, time

sites = [
    'https://www.yahoo.com/',
    'http://www.cnn.com',
    'http://www.python.org',
    'http://www.jython.org',
    'http://www.pypy.org',
    'http://www.perl.org',
    'http://www.cisco.com',
    'http://www.facebook.com',
    'http://www.twitter.com',
    'http://www.macrumors.com/',
    'http://arstechnica.com/',
    'http://www.reuters.com/',
    'http://abcnews.go.com/',
    'http://www.cnbc.com/',
]


async def show_len(sites):
    t1 = time.time()
    for url in sites:
        with urllib.request.urlopen(url) as u:
            page = u.read()
            print(url, len(page))
    print("code took to run", time.time() - t1)

if __name__ == "__main__":
    trio.run(show_len, sites)

和第二个(同样的速度):

import urllib.request
import trio, time

sites = [
    'https://www.yahoo.com/',
    'http://www.cnn.com',
    'http://www.python.org',
    'http://www.jython.org',
    'http://www.pypy.org',
    'http://www.perl.org',
    'http://www.cisco.com',
    'http://www.facebook.com',
    'http://www.twitter.com',
    'http://www.macrumors.com/',
    'http://arstechnica.com/',
    'http://www.reuters.com/',
    'http://abcnews.go.com/',
    'http://www.cnbc.com/',
]

async def link_user(url):
    with urllib.request.urlopen(url) as u:
        page = u.read()
        print(url, len(page))

async def show_len(sites):
    t1 = time.time()
    for url in sites:
        await link_user(url)
    print("code took to run", time.time() - t1)


if __name__ == "__main__":
    trio.run(show_len, sites)

那么应该如何使用 trio 来处理这个例子呢？

Answer 1

两件事:

首先，异步的重点是并发。它不会神奇地让事情变得更快；它只是提供了一个同时做多件事的工具包(这可能比按顺序做更快)。如果您希望事情同时发生，那么您需要明确提出请求。在 trio 中，您执行此操作的方法是创建一个 nursery，然后调用其 start_soon 方法。例如:

async def show_len(sites):
    t1 = time.time()
    async with trio.open_nursery() as nursery:
        for url in sites:
            nursery.start_soon(link_user, url)
    print("code took to run", time.time() - t1)

但是，如果您尝试进行此更改然后运行代码，您会发现它仍然并没有更快。为什么不？要回答这个问题，我们需要稍微回顾一下并了解“异步”并发的基本思想。在异步代码中，我们可以有并发任务，但 trio 实际上在任何给定时间只运行其中一个。所以你不能有两个任务实际上同时做某事。但是，您可以同时有两个(或更多)任务等待。在这样的程序中，花在 HTTP 请求上的大部分时间都花在等待响应返回上，因此可以通过使用并发任务来加速:我们启动所有任务，然后它们每个运行一段时间以发送请求，停止等待响应，然后在等待下一个运行一段时间，发送请求，停止等待响应，然后在等待下一个运行...你明白了。

嗯，实际上，在 Python 中，到目前为止我所说的一切也适用于线程，因为 GIL 意味着即使您有多个线程，实际上一次也只能运行一个。

在 Python 中，异步并发和基于线程的并发之间的最大区别在于，在基于线程的并发中，解释器可以随时暂停任何线程并切换到运行另一个线程。在异步并发中，我们只在源代码中标记的特定点在任务之间切换——这就是 await 关键字的作用，它向您显示任务可能暂停的位置以让另一个任务运行。这样做的好处是它使你的程序更容易推理，因为不同线程/任务交错和意外相互干扰的方式要少得多。缺点是可以编写不在正确位置使用 await 的代码，这意味着我们不能切换到另一个任务。特别是，如果我们停止并等待某事，但没有用 await 标记它，那么我们的整个程序都会停止，而不仅仅是发出阻塞调用的特定任务。

现在让我们再次查看您的示例代码:

async def link_user(url):
    with urllib.request.urlopen(url) as u:
        page = u.read()
        print(url, len(page))

请注意 link_user 根本不使用 await。这就是阻止我们的程序并发运行的原因:每次我们调用 link_user 时，它都会发送请求，然后等待响应，而不让任何其他程序运行。

如果在开头添加一些打印调用，您可以更容易地看到这一点:

async def link_user(url):
    print("starting to fetch", url)
    with urllib.request.urlopen(url) as u:
        page = u.read()
        print("finished fetching", url, len(page))

它打印出类似的东西:

starting to fetch https://www.yahoo.com/
finished fetching https://www.yahoo.com/ 520675
starting to fetch http://www.cnn.com
finished fetching http://www.cnn.com 171329
starting to fetch http://www.python.org
finished fetching http://www.python.org 49239
[... you get the idea ...]

为避免这种情况，我们需要切换到专为 trio 设计的 HTTP 库。希望将来我们会有熟悉的选项，例如 urllib3和 requests .在那之前，您最好的选择可能是 asks .

因此，您的代码重写为同时运行 link_user 调用，并使用异步 HTTP 库:

import trio, time
import asks
asks.init("trio")

sites = [
    'https://www.yahoo.com/',
    'http://www.cnn.com',
    'http://www.python.org',
    'http://www.jython.org',
    'http://www.pypy.org',
    'http://www.perl.org',
    'http://www.cisco.com',
    'http://www.facebook.com',
    'http://www.twitter.com',
    'http://www.macrumors.com/',
    'http://arstechnica.com/',
    'http://www.reuters.com/',
    'http://abcnews.go.com/',
    'http://www.cnbc.com/',
]

async def link_user(url):
    print("starting to fetch", url)
    r = await asks.get(url)
    print("finished fetching", url, len(r.content))

async def show_len(sites):
    t1 = time.time()
    async with trio.open_nursery() as nursery:
        for url in sites:
            nursery.start_soon(link_user, url)
    print("code took to run", time.time() - t1)


if __name__ == "__main__":
    trio.run(show_len, sites)

现在这应该比顺序版本运行得更快。

三重奏教程中对这两点进行了更多讨论:https://trio.readthedocs.io/en/latest/tutorial.html#async-functions

您可能还会发现此演讲很有用:https://www.youtube.com/watch?v=i-R704I8ySE