python 异步接口 返回进度 python 异步操作

多进程与多线程：

　　我们常见的 Linux、Windows、Mac OS 操作系统，都是支持多进程的多核操作系统。所谓多进程，就是系统可以同时运行多个任务。例如我们的电脑上运行着 QQ、浏览器、音乐播放器、影音播放器等。在操作系统中，每个任务就是一个进程。每个进程至少做一件事，多数进程会做很多事，例如影音播放器，要播放画面，同时要播放声音，在一个进程中，就有很多线程，每个线程做一件事，在一个进程中有多个线程运行就是多线程。可以在实验环境终端执行 ps -ef 命令来查看当前系统中正在运行的进程。

　　计算机的两大核心为运算器和存储器。常说的手机配置四核、八核，指的就是 CPU 的数量，它决定了手机的运算能力；128G、256G 超大存储空间，指的就是手机存储数据的能力。当我们运行一个程序来计算 3 + 5，计算机操作系统会启动一个进程，并要求运算器派过来一个 CPU 来完成任务；当我们运行一个程序来打开文件，操作系统会启动存储器的功能将硬盘中的文件数据导入到内存中。

　　一个 CPU 在某一时刻只能做一项任务，即在一个进程（或线程）中工作，当它闲置时，会被系统派到其它进程中。单核计算机也可以实现多进程，原理是第 1 秒的时间段内运行 A 进程，其它进程等待：第 2 秒的时间段内运行 B 进程，其它进程等待。。。第 5 秒的时间段内又运行 A 进程，往复循环。当然实际上 CPU 在各个进程间的切换是极快的，在毫秒（千分之一）、微秒（百万分之一）级，以至于我们看起来这些程序就像在同时运行。现代的计算机都是多核配置，四核八核等，但计算机启动的瞬间，往往就有几十上百个进程在运行了，所以进程切换是一定会发生的，CPU 在忙不迭停地到处赶场。注意，什么时候进行进程 、线程切换是由操作系统决定的，无法人为干预。

线程安全：

　　我们都知道在 MySQL 中有 “原子操作” 的概念，打个比方：A向B转账 100 块钱，在 MySQL 中需要两步操作：A账户减少 100 元，B账户增加 100 元。如果第一步操作完成后，意外情况导致第二步没有做，A肯定不答应，这是不允许发生的。如何保证其不发生呢？将两步操作设计成一个事务，事务里可以有多个步骤，其中任何一步出现问题，事务都将失败，前面完成的步骤全部回滚，就像什么事都没发生。这种操作就叫做原子操作，这种特性就叫做原子性。

　　在 Python 多线程中，变量是共享的，这也是相较多进程的一个优点，线程占用资源要少得多，但也导致多个 CPU 同时操作多个线程时会引起结果无法预测的问题，也就是说 Python 的线程不安全。

GIL 全局解释器锁：

　　如何解决线程安全问题？CPython 解释器使用了加锁的方法。每个进程有一把锁，启动线程先加锁，结束线程释放锁。打个比方，进程是一个厂房，厂房大门是开着的，门内有锁，工人进入大门后可以在内部上锁。厂房里面有 10 个车间对应 10 个线程，每个 CPU 就是一个工人。GIL（Global Interpreter Lock）全局锁就相当于厂房规定：工人要到车间工作，从厂房大门进去后要在里面反锁，完成工作后开锁出门，下一个工人再进门上锁。也就是说，任意时刻厂房里只能有一个工人，这样就保证了工作的安全性，这就是 GIL 的原理。当然了，GIL 的存在有很多其它益处，包括简化 CPython 解释器和大量扩展的实现。

　　根据上面的例子可以看出 GIL 实现了线程操作的安全性，但多线程的效率被大打折扣，一个工厂里只能有一个工人干活，很难想象。这也是 David Beazley（《Python 参考手册》和《Python Cookbook》的作者）说 “Python 线程毫无用处” 的原因。注意，GIL 不是语言特性，而是解释器的设计特点，有些 Python 解释器例如 JPython 就没有 GIL ，除了 Python 其它语言也有 GIL 设计，例如 Ruby 。

多线程提高工作效率：

　　实际情况并非上面讲得那么惨，Python 多线程可以成倍提高程序的运行速度，而且在多数情况下都是有效的。接着上面的例子说，一个工厂里同一时刻只能有一个工人在工作，如果这个工厂里各个车间的自动化程度极高且任务耦合度极低，工人进去只是按几下按钮，就可以等待机器完成其余工作，那情况就不一样了，这种场景下一个工人可以管理好多个车间，而且大多数时间都是等，甚至还能抽空打打羽毛球看场电影。

　　比如爬虫程序爬取页面数据这个场景中，CPU 做的事就是发起页面请求和处理响应数据，这两步是极快的，中间网络传输数据的过程是耗时且不占用 CPU 的。一个工人可以在吃完早饭后一分钟内快速到 1000 个车间按下发起请求的按钮，吃完午饭睡一觉，日薄西山时差不多收到网络传回的数据，又用一分钟处理数据，整个程序完成。

　　上面的场景中，CPU 再多也没有用处，一个 CPU 抽空就能完成整个任务了，毕竟程序中需要 CPU 做的事并不多。这就涉及到了复杂程序的分类：CPU 密集型和 IO 密集型。爬虫程序就是 IO 密集型程序。CPU 密集型程序全是手工操作，工人一刻也不能停歇，这种情况下 Python 多线程就真可以说是毫无用处了。

import threading
import time

def crawl_url():        # 假设这是爬虫程序，爬取一个 URL
    time.sleep(0.02)    # 模拟 IO 操作

def main1():            # 单线程程序
    for i in range(100):
        crawl_url()

def main2():            # 多线程程序
    thread_list = []
    for i in range(100):
        t = threading.Thread(target=crawl_url)
        t.start()
        thread_list.append(t)
    for t in thread_list:
        t.join()

if __name__ == '__main__':
    start = time.time()
    main1()
    end = time.time()
    print('单线程耗时：{:.4f}s'.format(end - start))
    start = time.time()
    main2()
    end = time.time()
    print('多线程耗时：{:.4f}s'.format(end - start))

运行结果：

单线程耗时：2.2983
多线程耗时：0.0340

理论上，main1 的耗时是 main2 的 100 倍，考虑到 main2 创建多线程、线程切换的开销，这个结果也是相当可观的，IO 操作耗时越长，多线程的威力越大。

异步和同步，阻塞和非阻塞：

　　上文的模拟爬虫示例代码中，main1 中的 for 循环运行 100 次爬取网页的操作，前一个完成后才能运行下一个，这就是同步的概念，在 crawl_url 函数内部的 IO 操作为阻塞操作，线程无法向下执行。

　　main2 中的第一个 for 循环，创建 100 个线程并启动，这步操作是非阻塞的，不会等一个线程运行完成才创建下一个线程，它会一气儿创建并启动 100 个线程；第二个 for 循环将主线程挂起，直到全部子线程完成，此时的主线程就是阻塞的。这种程序运行方式叫做异步，CPU 在遇到 IO 阻塞时不会站在那儿傻等，而是被操作系统派往其它线程中看看有什么事可做。

　　所谓的异步，就是 CPU 在当前线程阻塞时可以去其它线程中工作，不管怎么设计，在一个线程内部代码都是顺序执行的，遇到 IO 都得阻塞，所谓的非阻塞，是遇到当前线程阻塞时，CPU 去其它线程工作。

协程初步：

　　在多线程程序中，线程切换由操作系统决定，无法人为干预。上文的模拟爬虫示例代码中各个线程间无关联，没有先后顺序，不涉及互相引用，耦合性为零，这种场景使用多线程是很适合的。协程是在线程的基础上编写由程序员决定代码执行顺序、可以互相影响的高耦合度代码的一种高级程序设计模式。

　　上文说到 “不论如何设计，在一个线程内部，代码都是顺序执行的，遇到 IO 都得阻塞” ，直到出现了协程，这句话变成了伪命题。一个线程内部可以有多个协程，相当于一个车间内部有多个子任务，一个协程遇到 IO 阻塞，CPU 会自动去另一个协程中工作，而且去哪里工作由程序自己说了算，此外连创建线程和线程切换的开销都省了，这是一个多么大的比较优势！

生成器原理：

生成器可谓协程的立身之基，所以先谈生成器。这就要提到经典的斐波那契数列：

def fibonacci(n):
      a, b = 0, 1
      while b < n:
          a, b = b, a + b
          yield a
f = fibonacci(100)
for i in f:
    print(i)

　　函数体内部有 yield 关键字的都是生成器函数，fibonacci 是生成器函数。yield 关键字只能出现在函数中，生成器函数的执行结果是生成器，注意这里所讲的 “执行结果” 不是函数的 return 值。生成器终止时必定抛出 StopIteration 异常，for 循环可以捕获此异常，异常的 value 属性值为生成器函数的 return 值。生成器还可以使用 next 方法迭代。生成器会在 yield 语句处暂停，这是至关重要的，未来协程中的 IO 阻塞就出现在这里。

生成器进化成协程：

　　生成器是由迭代器进化而来，所以生成器对象有 __iter__ 和 __next__ 方法，可以使用 for 循环获得值，注意这里所说的 “获得值” 指的是下文代码块里 yield 语句中 yield 关键字后面的 i 。这是在 Python 2.5 时出现的特性，在 Python 3.3 中出现 yield from 语法之前，生成器没有太大用途。但此时 yield 关键字还是实现了一些特性，且至关重要，就是生成器对象有 send 、throw 和 close 方法。这三个方法的作用分别是发送数据给生成器并赋值给 yield 语句、向生成器中抛入异常由生成器内部处理、终止生成器。这三个方法使得生成器进化成协程。

生成器（或协程）有四种存在状态：

• GEN_CREATED 创建完成，等待执行
• GEN_RUNNING 解释器正在执行（这个状态在下面的示例程序中无法看到）
• GEN_SUSPENDED 在 yield 表达式处暂停
• GEN_CLOSE 执行结束，生成器停止

可以使用 inspect.getgeneratorstate 方法查看协程的当前状态，举例如下：

import inspect
def generator():
    i = '激活生成器'
    while True:
          try:
              value = yield i
          except ValueError:
              print('OVER')
          i = value

g = generator()

inspect.getgeneratorstate(g)
'GEN_CREATED'

next(g)
'激活生成器'

inspect.getgeneratorstate(g)
'GEN_SUSPENDED'

g.send('Hello Shiyanlou')
'Hello Shiyanlou'

g.throw(ValueError)
OVER
'Hello Shiyanlou'

g.close()

inspect.getgeneratorstate(g)
'GEN_CLOSED'

代码说明如下：

1、创建生成器

2、查看生成器状态

3、这步操作叫做预激生成器（或协程），这是必须要做的。在生成器创建完成后，需要将其第一次运行到 yield 语句处暂停

4、暂停状态的生成器可以使用 send 方法发送数据，此方法的参数就是 yield 表达式的值，也就是 yield 表达式等号前面的 value 变量的值变成 'Hello Shiyanlou'，继续向下执行完一次 while 循环，变量 i 被赋值，继续运行下一次循环，yield 表达式弹出变量 i

5、向生成器抛入异常，异常会被 try except 捕获，作进一步处理

6、close 方法终止生成器，异常不会被抛出

因为生成器的调用方也就是程序员自己可以控制生成器的启动、暂停、终止，而且可以向生成器内部传入数据，所以这种生成器又叫做协程，generator 函数既可以叫做生成器函数，也可以叫协程函数，这是生成器向协程的过渡阶段。

预激协程：

　　预先激活生成器（或协程）可以使用 next 方法，也可以使用生成器的 send 方法发送 None 值：g.send(None) 。为简化协程的使用，我们可以尝试编写一个装饰器来预激协程，这样创建的协程会立即进入 GEN_SUSPENDED 状态，可以直接使用 send 方法：

In [212]: from functools import wraps

In [213]: def coroutine(func):  # 预激协程装饰器
     ...:     @wraps(func)      # wraps 装饰器保证 func 函数的签名不被修改
     ...:     def wrapper(*args, **kw):
     ...:         g = func(*args, **kw)
     ...:         next(g)       # 预激协程
     ...:         return g      # 返回激活后的协程
     ...:     return wrapper
     ...:

In [214]: @coroutine            # 使用装饰器重新创建协程函数
     ...: def generator():
     ...:     i = '激活生成器'
     ...:     while True:
     ...:         try:
     ...:             value = yield i
     ...:         except ValueError:
     ...:             print('OVER')
     ...:         i = value
     ...:

In [215]: g = generator()

In [216]: inspect.getgeneratorstate(g)
Out[216]: 'GEN_SUSPENDED'

协程的返回值：

　　前文 “生成器原理” 这一小节中提到了 StopIteration 异常的 value 属性值为生成器（协程）函数的 return 值，我们可以在使用协程时捕获异常并得到这个值。举例如下：

In [217]: @coroutine
     ...: def generator():
     ...:     l = []                    # 1
     ...:     while True:
     ...:         value = yield         # 2
     ...:         if value == 'CLOSE':  # 3
     ...:             break
     ...:         l.append(value)       # 4
     ...:     return l                  # 5
     ...:

In [218]: g = generator()

In [219]: g.send('hello')

In [220]: g.send('shiyanlou')

In [221]: g.send('CLOSE')
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-221-863c90462435> in <module>
----> 1 g.send('CLOSE')

StopIteration: ['hello', 'shiyanlou']

代码说明如下：

1、创建列表，保存协程 send 方法每次发送的参数

2、yield 表达式不弹出值，仅作暂停之用

3、如果 send 方法的参数为 CLOSE ，break 终止 while 循环，停止生成器，抛出 StopIteration 异常

4、将 value 添加到列表

5、设置协程函数的返回值，该值在协程终止抛出 StopIteration 异常时赋值给 value 属性

可以这样捕获异常：

In [231]: g = generator()

In [232]: for i in ('hello', 'shiyanlou', 'CLOSE'):
     ...:     try:
     ...:         g.send(i)
     ...:     except StopIteration as e:
     ...:         value = e.value  # e 的 value 属性值就是协程函数的 return 值
     ...:         print('END')
     ...:
END

In [233]: value
Out[233]: ['hello', 'shiyanlou']

yield from：

在 Python 3.3 中新增了 yield from 语法，这是全新的语言结构，是 yield 的升级版。相比 yield ，该语法有两大优势，我们来举例说明它的用法。

（一）避免嵌套循环

我们知道 Python 内置模块 itertools 是十分强大的，里面有很多实用的方法，其中之一是 chain 方法，它可以接受任意数量的可迭代对象作为参数，返回一个包含所有参数中的元素的迭代器：

In [8]: from itertools import chain

In [9]: c = chain({'one', 'two'}, list('ace'))

In [10]: c 
Out[10]: <itertools.chain at 0x1066020f0>

In [11]: for i in c:
    ...:     print(i)
    ...:
one
two
a
c
e

使用 yield 关键字实现 chain 方法：

In [16]: def chain(*args):
    ...:     for iter_obj in args:
    ...:         for i in iter_obj:
    ...:             yield i
    ...:

In [17]: c = chain({'one', 'two'}, list('ace'))

In [18]: c
Out[18]: <generator object chain at 0x1066ff570>

In [19]: for i in c:
    ...:     print(i)
    ...:
one
two
a
c
e

这样就实现了类似 itertools 中的 chain 方法，注意这里 chain 函数的返回值是生成器，现在我们使用 Python 3.3 新增的 yield from 语法优化上文的 chain 函数：

In [20]: def chain(*args):
    ...:     for iter_obj in args:
    ...:         yield from iter_obj
    ...:

In [21]: c = chain({'one', 'two'}, list('ace'))

In [22]: c
Out[22]: <generator object chain at 0x106a95b88>

In [23]: for i in c:
    ...:     print(i)
    ...:
one
two
a
c
e

可以看到 yield from 语句可以替代 for 循环，避免了嵌套循环。同 yield 一样，yield from 语句也只能出现在函数体内部，有 yield from 语句的函数叫做协程函数或生成器函数。

yield from 后面接收一个可迭代对象，例如上面代码中的 iter_obj 变量，在协程中，可迭代对象往往是协程对象，这样就形成了嵌套协程。

转移控制权：

　　转移控制权是 yield from 语法的核心功能，也是从生成器进化到协程的最重要一步。

　　首先安装伪造数据的库 faker ，在终端执行 sudo pip3 install faker 即可。

下面举例说明转移控制权的功能，将以下代码写入 transfer_control.py 文件中，这是一个可以将列表进行排序的程序。对代码的注释写入每行代码前面或后面，方便阅读。