摘要：定義一個閉包相關官方文檔是一種用于并發編程的模式，首次引入是在的模塊。對象是一個對于異步返回結果的占位符。一個對象包含了一次異步操作的結果。在同步編程中，被用于等待從一個線程池或進程池里返回的結果在中，通常被用在或者在一個函數中它們。

from tornado.concurrent import Future

def async_call_method(fun, *args, **kwargs):
    future = Future()
    // 定義一個閉包 finish
    def finish():
        try:
            result = fun(*args, **kwargs)
            if future._callbacks:
                IOLoop.current().add_callback(future.set_result, result)
            else:
                future.set_result(result)
        except:
            if future._callbacks:
                IOLoop.current().add_callback(future.set_exc_info, sys.exc_info())
            else:
                future.set_exc_info(sys.exc_info())
    child_gr = greenlet.greenlet(finish)
    child_gr.switch()
    return future

Future 是一種用于并發編程的模式，首次引入是在 python 3.2 的 concurrent.futures 模塊。

Future 對象是一個對于異步返回結果的占位符。

一個 Future 對象包含了一次異步操作的結果。在同步編程中，Futures 被用于等待從一個線程池或進程池里返回的結果；在 tornado 中，future 通常被用在 IOLoop.add_future 或者在一個 gen.coroutine 函數中 yielding 它們。

tornado.concurrent.Future 和 concurrent.futures.Future 相似，但是其不是線程安全的(因此，在單線程事件循環應用在速度更快)

經過一番搜索，查詢到 async_call_method() 這個函數來自于 github.com/snower/TorMySQL.

經過對該項目代碼的仔細閱讀，我發現了它是如何實現了 mysql 的異步操作。

...
def connect(self):
    # 入口函數
    # 設置 future 占位符
    future = Future()

    # 定義回調函數
    def on_connected(connection_future):
        if connection_future._exc_info is None:
            future.set_result(self)
        else:
            future.set_exc_info(connection_future.exc_info())
    self._connection = Connection(defer_connect = True, *self._args, **self._kwargs)
    self._connection.set_close_callback(self.connection_close_callback)

    # 用 greenlet 包裝 self._connection.connect 并返回 future
    # 要使 async_call_method 包裝后的函數有非阻塞的特性，必須達成以下要求
    # 1. 函數可以訪問 父greenlet
    # 2. 函數中所有 IO 操作均支持非阻塞(比如: 非阻塞由 socket 的 non-blocking 特性支持)
    # 3. 函數中執行 IO 操作后立即將運行權交還給主函數(父greenlet, 如：ioloop 時間循環)(greenlet.switch)
    # 4. 函數中所有 IO 操作均返回 Future
    # 5. Future.callback 運行后立即將運行權(greenlet.switch)返回給當前函數(greenlet.current)，完成當前函數的剩余部分
    connection_future = async_call_method(self._connection.connect)

    # 當 connection_future 狀態為 finished, 調用 on_connected()
    # finished => 調用 connection_future.set_result()
    IOLoop.current().add_future(connection_future, on_connected)
    return future
...

...
        # IOStream 基于 tornado.iostream.IOStream
        sock = IOStream(sock)
        sock.set_close_callback(self.stream_close_callback)

        # getcurrent() 返回包裝了當前函數的 greenlet
        child_gr = greenlet.getcurrent()
        # main 是指 父greenlet(主函數, 時間循環?)
        main = child_gr.parent
        assert main is not None, "Execut must be running in child greenlet"
...
    def connected(future):
        if self._loop_connect_timeout:
            self._loop.remove_timeout(self._loop_connect_timeout)
            self._loop_connect_timeout = None
    
        if future._exc_info is not None:
            child_gr.throw(future.exception())
        else:
            self._sock = sock
            # 將運行權交還給當前 greenlet
            child_gr.switch()
    
    # IOStream.connect 是 no-blocking 的 socket 操作
    future = sock.connect(address)
    # 給 sock.connect 操作添加回調函數
    self._loop.add_future(future, connected)
    # 然后把運行權交還給 父greenlet
    # 直到連接成功，connected() 中會將運行權交還給 當前greenlet
    main.switch()
...

要使 async_call_method 包裝后的函數有非阻塞的特性，必須達成以下要求

函數可以訪問 父greenlet

函數中所有 IO 操作均支持非阻塞(比如: 非阻塞由 socket 的 non-blocking 特性支持)

函數中執行 IO 操作后立即將運行權交還給主函數(父greenlet, 如：ioloop 時間循環)(greenlet.switch)

函數中所有 IO 操作均返回 Future

Future.callback 運行后立即將運行權(greenlet.switch)返回給當前函數(greenlet.current)，完成當前函數的剩余部分

async_call_method 包裝后的函數要實現非阻塞，最終還是依賴于 socket 的非阻塞
=> socket.setblocking(False)。

github.com/snower/TorMySQL 中于 mysql 的交互全部通過 IOStream() 的以下方法實現:

* def _handle_events(self, fd, events):  # ioloop 在事件發生時調用 _handle_events
* def _handle_connect(self): 
* def _handle_read(self):  # 當事件為讀取事件時，讀取數據到 buffer, 然后 future.set_result(data)
* def _handle_write(self):  # 當事件為寫事件時，讀取數據到 buffer, 然后 future.set_result(data)
* def read(self, num_bytes):
* def write(self, data):

通過對上述方法進行 設置 future 占位符，并基于 non-blocking socket 實現上述方法的非阻塞。