我试图理解 Tornado 文档介绍页面上提供的基本示例。它有 2 个代码块。同步的对我来说很好，我理解它。但是异步的是我无法理解的。

同步

from tornado.httpclient import HTTPClient

def synchronous_fetch(url):
    http_client = HTTPClient()
    response = http_client.fetch(url)
    return response.body

异步

from tornado.httpclient import AsyncHTTPClient

def asynchronous_fetch(url, callback):
    http_client = AsyncHTTPClient()
    def handle_response(response):
        callback(response.body)
    http_client.fetch(url, callback=handle_response)

如果您能提供更好的示例，请提供。

最佳答案

异步 调用的想法在许多与网络相关的编程中几乎是一样的...“东西”(框架、服务器、库... ) 不仅仅是来自 Tornado 网络服务器的概念。

基本思路是:

• 在 s̲y̲n̲c̲h̲r̲o̲n̲o̲u̲s̲ 请求中，你发出请求并停止执行你的程序，直到你从 HTTP 服务器收到响应(或者如果无法访问服务器则出现错误，或者如果服务器正在占用则超时，方式回复时间太长)解释器被阻塞，直到请求完成(直到你得到关于请求发生的事情的明确答案:进展顺利吗？有错误吗？超时？.. . ).

• 在收到 a̲s̲y̲n̲c̲h̲r̲o̲n̲o̲u̲s̲ 请求时，你“启动” 请求，然后你“忘记它”，意思是:解释器在之后继续执行代码无需等待请求完成即可发出请求。

  这似乎……毫无意义，对吧？您发送请求“到空间的虚空”，并继续照常执行？当服务器向您发送响应时会发生什么？我提出了一个请求，我想知道它发生了什么!否则，我一开始就不会在我的代码中输入它!!

  好吧，这就是回调的用武之地。您“向虚无空间”发起请求 但是您提供了一个回调函数因此，当另一端的 HTTP 服务器向您发送其响应时，该函数将以所述 response 作为第一个参数运行。

让我们看一个例子。

我创建了一个非常简单的 Tornado 服务器(使用 Python 2.7 和 Tornado 4.2)，只有一个处理程序。在 GET 上，返回需要 5 秒。我用 time.sleep 做到了这一点，但在现实生活中，这可能是一个非常耗时的过程(访问数据库、执行一些计算……谁知道呢？……)

这是服务器文件(基于 Tornado 文档中提供的 example):

示例服务器.py:

#!/usr/bin/env python2.7
import time
import tornado.ioloop
import tornado.web


class MainHandler(tornado.web.RequestHandler):
    def get(self):
        print "Someone is GET'ing me"
        time.sleep(5)
        self.write("Hello, world")

application = tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    application.listen(8888)
    print "Starting sample server."
    tornado.ioloop.IOLoop.current().start()

打开终端并运行该代码以获得服务器。您将在本地计算机的端口 8888 上监听 Tornado。

现在，让我们创建另一个脚本(您必须在另一个终端中运行)，它以两种方式GEThttp://localhost:8888:首先同步然后异步。

SampleFetcher.py:

#!/usr/bin/env python2.7
import datetime
import tornado.ioloop
from tornado.httpclient import HTTPClient, AsyncHTTPClient


def HUMAN_DT_NOW():
    return datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S")


def synchronous_fetch(url):
    http_client = HTTPClient()
    start_dt = datetime.datetime.now()
    response = http_client.fetch(url)
    end_dt = datetime.datetime.now()
    print ("The synchronous fetch took %s seconds."
           % (end_dt - start_dt).total_seconds())
    print "(Sync) Server said: \"%s\"" % response.body


def asynchronous_fetch(url):
    http_client = AsyncHTTPClient()

    def handle_response(response):
        print ""
        print "Yawwza... Finally!!!."
        print "The time now is %s" % HUMAN_DT_NOW()
        print "(Async) Server said: \"%s\"" % response.body
    print "Gonna launch a 'fetch' to the universe at %s..." % HUMAN_DT_NOW()
    http_client.fetch(url, callback=handle_response)

if __name__ == "__main__":
    print " ------ Synchronous ------ "
    print ("Starting synchronous fetch at %s."
           " The program will block for about 5 secs." % HUMAN_DT_NOW())
    synchronous_fetch('http://localhost:8888')
    print "Pfew! That was a lot of wait time!!. I got bored watching my terminal"
    print ""
    print "Aight, let's see what Asynchronous can do"
    print " ------ Asynchronous ------ "
    asynchronous_fetch('http://localhost:8888')
    print "You're gonna see this line before the \"Yawwza...\" one"
    print "This one too. Now is %s" % HUMAN_DT_NOW()
    # The IOLoop below is required to prevent the script from closing ahead
    # of time, but allowing Asynchronous interactions
    tornado.ioloop.IOLoop.current().start()

这将输出:

Starting synchronous fetch at 2015/07/04 13:25:47. The program will block for about 5 secs.
The synchronous fetch took 5.009597 seconds.
(Sync) Server said: "Hello, world"
Pfew! That was a lot of wait time!!. I got bored watching my terminal

Aight, let's see what Asynchronous can do
 ------ Asynchronous ------ 
Gonna launch a 'fetch' to the universe at 2015/07/04 13:25:52...
You're gonna see this line before the "Yawwza..." one
This one too. Now is 2015/07/04 13:25:52

Yawwza... Finally!!!.
The time now is 2015/07/04 13:25:57
(Async) Server said: "Hello, world"

这里让我们关注异步部分:

 ------ Asynchronous ------ 
Gonna launch a 'fetch' to the universe at 2015/07/04 13:25:52...
You're gonna see this line before the "Yawwza..." one
This one too. Now is 2015/07/04 13:25:52

Yawwza... Finally!!!.
The time now is 2015/07/04 13:25:57
(Async) Server said: "Hello, world"

如果您看到，脚本在 13:25:52 进行了 asynchronous_fetch，但是立即(在同一秒内)，解释器继续执行，并在发出请求后运行下一条语句(打印 You're gonna see this line before the "Yawwza..."one 和 This one too.现在是 2015/07/04 13:25:52)。

然后，大约 5 秒后，服务器响应，执行了 callback 函数(即 handle_response)，这时你看到了

Yawwza... Finally!!!.
The time now is 2015/07/04 13:25:57

我希望这有助于理解这个想法。这是一个非常有用的概念，它不仅适用于 Tornado。

随意使用提供的两个示例脚本，更改内容，增加服务器回复的时间...

进一步推荐阅读:

• What is the Asynchronous Web, and How is it Revolutionary?
• Asynchronous vs. synchronous calls
• Asynchronous vs synchronous execution, what does it really mean?
• Tornado's Futures

关于python - 同步与异步，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31079717/