大猪 & 大兔

终于用透支生命的方法把这一课学完了。感动。以后不这样了。
实现异步非阻塞是一个大命题，这里只从原理出发。我会慢慢修改这篇文章。
本文将从异步sleep的实现入手，来讲解异步非阻塞程序的原理。

什么是异步，同步，阻塞，非阻塞

在写这篇文章前，我对这四个概念是非常模糊的。

同步，异步

异步同步的差异，在于当线程调用函数的时候，线程获取消息的方式.
如果是同步，线程会等待接受函数的返回值（或者轮循函数结果，直到查出它的返回状态和返回值）。如果是异步，线程不需要做任何处理，在函数执行完毕后会推送通知或者调用回调函数。

同步： 线程 ——我主动来拿结果——> 函数
异步： 线程 <—-你把结果拿给我—— 函数

阻塞，非阻塞

阻塞非阻塞的差异，在于线程调用函数的时候，线程的状态。
当线程调用函数，线程就被挂起，在函数结束前什么都干不了。这就是阻塞。
反之，当线程调用函数，线程还能干其它事。这就是非阻塞。此时，函数一般会立即返回状态，而不是等待求值。以免阻塞住线程。

他们没有关系

异步同步和阻塞非阻塞没有什么本质关联。一个讲的是消息方式，一个讲的是线程状态。
线程在同步调用下，也能非阻塞（同步轮循非阻塞函数的状态），在异步下，也能阻塞（调用一个阻塞函数，然后在函数中调用回调，虽然没有什么意义）。

下面，我会慢慢实现一个异步非阻塞的sleep。最后利用Python的特性，将callback调用方式改为yield的伪同步调用。

场景一：同步阻塞

import time
def wait(name):
    print(name, " start")
    time.sleep(1)
    print(name," is over")
wait("yzh")
wait("zhh")

上面的程序执行完毕后，想都不用想，输出如下：

打印 yzh start
# 等待1s
打印 yzh is over
打印 zhh start
# 等待1s
打印 zhh is over

阻塞的后果

上面的代码，如果调用次数很多，则最后一个人要等待之前所有的人阻塞结束，才能被响应。在web项目中，这是很可怕的。所以我们需要引入非阻塞。非阻塞就是为了让一个响应的操作，不影响另一个响应。否则，当A用户在访问某个耗时巨大的网页时，B用户只能对着白板发呆。

在tornado中，有一个gen.sleep函数。它能让响应神奇的变成：

打印 yzh start
打印 zhh start
# 等待1s左右
打印 yzh is over
打印 zhh is over

这个异步sleep函数，似乎在单进程下，让每个函数互相不影响，而又在内部停留了1S。
那么，我们该如何实现自己的非阻塞sleep呢。
（tornado的sleep，原理十分复杂。以后再细说。）

场景二：轮循非阻塞

实现非阻塞场景，关键在于函数不能阻塞住当前线程。也就是说，要启用新的线程让系统帮忙调度，或者以自己的方式确保所有任务都能被调度（比如yield切换来切换去）。

使用线程

import time
from multiprocessing.dummy import Pool as ThreadPool
class Status(object):
    pass
p = ThreadPool(4)
def my_sleep():
    status = Status()
    status.status = 0
    def _inner():
        time.sleep(2)
        status.status = 1
    p.apply_async(_inner)
    return status
def wait(name):
    print(name, " start")
    yield my_sleep()
    print(name, "over")
gen1 = wait("yzh")  # wait是一个生成器，保存为gen1
gen2 = wait("zhh")
timer1 = next(gen1)
timer2 = next(gen2)
tasks = []
tasks.append([gen1,timer1])
tasks.append([gen2,timer2])
while tasks:
    for task in tasks:
        if task[1].status == 1:
            try:
                next(task[0]) # 状态正确则继续执行父生成器
            except StopIteration:
                tasks.remove(task)

使用线程没什么好说的，线程会更新状态，当状态更新后，在下次轮循会触发生成器继续执行后面的动作。

不使用线程

import time
def my_sleep(now):
    """
    这个函数本来就是一个生成器。所以可以在单线程下切换运行状态。
    """
    while time.time() < now + 2:
        yield
def wait(name):
    print(name, " start")
    now = time.time()
    yield my_sleep(now)
    print(name, " is over")
gen1 = wait("yzh")  # wait是一个生成器，保存为gen1
gen2 = wait("zhh")
timer1 = next(gen1)  # 当执行gen的时候，它会Yield一个timer生成器。
                    # timer是生成器，这是我们可以在单线程下切换timer上下文的关键。
timer2 = next(gen2)
tasks = []
tasks.append([gen1,timer1])
tasks.append([gen2,timer2])
while tasks:
    for task in tasks:
        try:
            next(task[1])  # 不断的轮循每个生成器关连的timer。直到timer执行完毕，引发异常。
        except StopIteration:
            try:
                next(task[0]) # 当timer异常，我们可以知道它的父生成器要继续执行了。
                              # 对应的yield my_sleep(now) 执行完毕。可以继续下一步，所以我们对父生成器发送继续执行指令
            except StopIteration:
                tasks.remove(task)  # 当父生成器也执行完毕，整个任务终止。把当前任务移除任务队列。

上面的代码中，在一个while循环中轮循timer的状态。由于timer存在于wait中。所以需要把timer“提取”出来。
又因为，没有使用多线程，所以必须自己实现一些简单的调度处理，也就是说，要能自由的切换各个timer的上下文。在单线程下可以使用yield。

1. 把timer 从生存器gen yield返回出来
2. 轮循timer的状态（实质是切换进出timer，看它有没有引发StopIteration异常）
3. 如果发生了异常说明gen应该执行下一步操作了。next(gen)
4. 如果gen也发生了StopIteration异常，说明这个任务完毕。

场景三：异步非阻塞

实现异步的经典方式是使用回调，实现非阻塞的经典方式是使用线程。
所以，代码就呼之欲出了。

import time
from multiprocessing.dummy import Pool as ThreadPool
def my_sleep(callback, *callback_args):
    def _inner():
        time.sleep(2)
        callback(*callback_args)
    p.apply_async(_inner)
def wait(name):
    print(name, " start")
    my_sleep(wait_callback,name)
def wait_callback(name):
    print(name, " is over")
p = ThreadPool(4)
wait("yzh")
wait("zhh")
p.close()
p.join()

在wait中，唤起my_sleep函数。由于my_sleep在新线程中执行，所以它不会阻塞住主线程。
在my_sleep结束时，调用回调函数。使得任务继续进行。
也就是说，在每个要处理阻塞的地方，都人为的把函数切成三个部分：

1. 执行函数前半部
2. 执行新线程，把后半部作为回调函数传入。函数退出。
3. 等待后半部在线程完毕后被执行。

场景四：终极，伪同步实现异步非阻塞

这个以后再写。先吃饭。