在 Python 中如何使用并发模型编程-阿里云开发者社区

import itertools

import time

from threading import Thread, Event

def spin(msg: str, done: Event) -> None:

    for char in itertools.cycle(r'\|/-'):

        status = f'\r{char} {msg}'

        print(status, end='', flush=True)

        if done.wait(0.1):

            break

    blanks = ' ' * len(status)

    print(f'\r{blanks}\r', end='')

def slow() -> int:

    time.sleep(3)

    return 42

threading 模块提供多线程支持， Thread 实例用来管理一个新的线程， Event 可以用来进行线程间通信。

spin 函数将作为一个任务在单独的线程中执行，它接收两个参数 msg 、 done ，传递进来的 msg 将会跟随旋转指针一起被打印， done 参数类型为 threading.Event ，用来实现多个线程间的通信，以此来同步任务状态。

itertools.cycle(r'\|/-') 是一个无限迭代器，一次产出一个字符，不停的迭代。比如用 for 遍历 itertools.cycle('123') ，将得到无限迭代的数据 123123123... 。这里 \|/- 字符不停迭代并被打印，就会产生旋转指针的效果。

打印的 status 字符串第一个字符为 \r ，可以实现将光标移动到行首，这是一个使用文本在控制台实现动画的小技巧。

接下来的 done.wait(0.1) 是这个函数的关键代码，它是主线程与执行当前函数的子线程之间通信的桥梁。 done.wait 方法签名为 Event.wait(self, timeout=None) ，该方法等待 timeout 指定的时间后返回 False ，我们在这里指定为 0.1 秒。如果在其他线程中使用 Event.set() 设置了这个事件，则当前线程该方法将立即返回 True ，此时 for 循环就会被 break 掉。

spin 函数在退出前，还会打印几个空格来实现清空当前行打印内容的效果，并且最终还将光标移动到行首。

slow 函数使用 time.sleep(3) 暂停 3 秒，模拟耗时操作，这个函数将像我们往常编写的单线程代码一样在主线程中执行。

接下来我们要编写多线程代码来分别调用 spin 和 slow 两个函数，完成这个旋转指针程序。

def supervisor() -> int:

    done = Event()

    spinner = Thread(target=spin, args=('thinking!', done))

    print(f'spinner object: {spinner}')

    spinner.start()

    result = slow()

    done.set()

    spinner.join()

    return result

def main() -> None:

    result = supervisor()

    print(f'Answer: {result}')

if __name__ == '__main__':

    main()

supervisor 函数中，首先实例化了一个 Event 对象，用于多线程通信。

接着，又实例化了一个 Thread 对象，用来管理子线程， target 参数接收一个函数 spin ，这个函数将在一个独立的子线程中执行， args 参数接收一个元组，在子线程中调用 spin 函数时，元组的各个参数将被原样传递给 spin 函数。

Thread 对象必须要显式的调用 start 方法才能启动，所以代码执行到 spinner.start() 时，子线程才会真正开始执行。子线程只会执行 spin 函数，至于下方的代码与子线程无关，都是主线程要执行的代码。

子线程的执行对主线程执行不会产生影响，主线程代码会继续往下运行，主线程调用 slow() 时会被耗时任务所阻塞。此时，子线程内部代码执行不受影响，所以子线程会不停的打印旋转指针。

等待 3 秒结束后，主线程中 slow() 函数返回结果，主线程调用 done.set() 将 Event 对象设置为 True 。此时，子线程 spin 函数内部 done.wait(0.1) 会立即返回 True ，随即 for 循环终止， spin 执行完成后子线程也就退出了。

主线程不受子线程退出影响，会接着往下执行，调用 spinner.join() 是为了等待子线程结束，主线程会阻塞在这里，保证子线程结束后才会往下执行。显然，子线程在执行完 spin 函数就结束了，所以主线程代码会继续往下执行。

supervisor 函数最终返回 slow 方法的返回值 result 。

入口函数 main 打印 result 值后，主线程也退出了，程序终止。

以上，就是多线程版旋转指针程序的全部逻辑了。

我们来测试下这个程序执行效果：

spinner-thread

多线程对象 spinner 输出结果为 <Thread(Thread-1, initial)> ，其中 Thread-1 是线程名称， initial 是线程状态，表示当前线程刚初始化完成，尚未启动。

多进程版

Python 提供了 multiprocessing 来支持多进程，这个模块的 API 基本模仿了多线程的 threading 模块，所以有了前文的基础，多进程代码也非常容易看懂。

同多线程一样， multiprocessing 包也为多进程通信提供了 Event 对象。不同的是， threading.Event 是一个类， multiprocessing.Event 是一个函数，它返回一个 synchronize.Event 类实例。所以 spin 函数签名需要进行如下修改：

from multiprocessing import Process, Event

from multiprocessing import synchronize

def spin(msg: str, done: synchronize.Event) -> None:

...

spin 函数内部代码无需调整，只需要修改参数 done 的类型注解即可。所以不难发现 synchronize.Event 同样支持 Event.wait(self, timeout=None) 方法。

多进程版本的 supervisor 函数也要稍作修改：

def supervisor() -> int:

    done = Event()

    spinner = Process(target=spin, args=('thinking!', done))

    print(f'spinner object: {spinner}')

    spinner.start()

    result = slow()

    done.set()

    spinner.join()

    return result

虽然 multiprocessing.Event 和 threading.Event 类型不同，但二者用法和作用则完全相同。

这里使用 Process 实例化一个进程对象， Process 用法和 Thread 用法同样如出一辙。

只需要对代码做少量的改动，我们就将程序从多线程迁移到了多进程。这一点，Python 做的非常友好，掌握了多线程编程，基本上就掌握了多进程编程，我们只需要在适当的时候，使用不同的模块即可。

下面是多进程版本旋转指针程序测试效果：

spinner-process

多进程对象 spinner 输出结果为 <Process name='Process-1' parent=94367 initial> ，进程名称为 Process-1 ， parent 代表父进程 ID 为 94367 （即主进程 ID）， initial 是进程状态，表示当前进程刚初始化完成，尚未启动。

协程版

最后我们将使用协程实现旋转指针程序，这一版本代码改动会比较大。

Python 在 3.5 版本提供了 async 、 await 关键字（可以参考 PEP 492 ），开始原生支持了协程，我们不再需要编写难懂的 yeild from 来使用生成器实现协程功能了。

Python 协程通常在单线程的事件循环中运行。协程是一个可以挂起自身并在以后恢复的“函数”， async 用来定义协程，一个协程必须显式的使用 await 关键字主动让出控制权，另一个协程才有机会在主事件循环的调度下并发的执行。

协程版本旋转指针程序需要对 spin 和 slow 两个函数做如下修改：

import asyncio

import itertools

async def spin(msg: str) -> None:

    for char in itertools.cycle(r'\|/-'):

        status = f'\r{char} {msg}'

        print(status, end='', flush=True)

        try:

            await asyncio.sleep(0.1)

        except asyncio.CancelledError:

            break

    blanks = ' ' * len(status)

    print(f'\r{blanks}\r', end='')

async def slow() -> int:

    await asyncio.sleep(3)

    return 42

首先我们使用 async def 将 spin 定义为一个协程，让其不再是一个常规的函数。

spin 协程取消了第二个参数，因为 Python 没有为协程提供 Event 对象来进行通信，我们需要采用其他招式。

在原来使用 Event 通信的地方替换成了由 try/except 包裹的 await asyncio.sleep(0.1) 语句块代码。这段代码块有如下三个作用：

await asyncio.sleep(0.1) 的作用类似 time.sleep ，可以让程序暂停 0.1 秒。不同的是，使用 await asyncio.sleep 暂停时不阻塞其他协程。
因为这里加入了 await 关键字，代码执行到这里时，当前协程会主动让出控制权，不再继续往下执行，由事件循环来调度其他协程执行。
如果在控制当前协程的 Task 实例中调用 cancel 方法（有关 Task 的内容稍后会进行讲解）， await asyncio.sleep(0.1) 会抛出 CancelledError 异常，这里使用 try/except 捕获异常后退出循环。这样，我们就在多个协程间利用异常机制完成了通信，而不必借助于额外的 Event 对象。

slow 函数也被改造为一个协程，其内部原来编写的阻塞代码 time.sleep(3) 被替换为了 await asyncio.sleep(3) 。

可以发现，其实协程与普通的函数在定义上差别不大，只不过多了两个关键字 async 和 await 。但二者在执行方式上大有不同，普通函数在使用 () 运算符调用时（即 spin() ）会立刻执行，而协程在使用 spin() 时只会创建一个协程对象，不会执行。

要执行上面两个协程对象，我们还要对 supervisor 和 main 函数进行改造：

async def supervisor() -> int:

    spinner = asyncio.create_task(spin('thinking!'))

    print(f'spinner object: {spinner}')

    result = await slow()

    spinner.cancel()

    return result

def main() -> None:

    result = asyncio.run(supervisor())

    print(f'Answer: {result}')

if __name__ == '__main__':

    main()

supervisor 函数同样被修改为协程， spin('thinking!') 并不会像函数一样立即执行，只会创建一个协程对象，将它传递给 asyncio.create_task ，我们可以得到一个 asyncio.Task 对象，这个 Task 对象包装了协程对象并调度其执行，它还提供控制和查询协程对象运行状态的方法。

使用 await 关键字来调用 slow 协程，这将阻塞 supervisor 程序（但会让出控制权，使其他协程得以执行），直到 slow 返回，返回结果赋值给 result 变量。

接着调用了 spinner.cancel() ， Task.cancel 方法调用后，将立即在 Task 所包装的协程对象即 spin 协程中抛出 CancelledError 异常， spin 中需要使用 try/except 捕获 await asyncio.sleep(0.1) 抛出的异常，这样，就实现了不同协程之间通过异常进行通信。

main 是唯一的普通函数，没有被改造为协程。 main 函数中的 asyncio.run 是整个协程的启动入口， asyncio.run 函数启动事件循环，驱动 supervisor() 协程运行，最终也将启动其他协程。

在以上示例代码中，我们可以总结出运行协程的 3 种方式：

asyncio.run(coroutine()) ：在一个常规函数中调用，是协程启动入口，将开启协程的事件循环，调用后保持阻塞，直至拿到 coroutine() 的返回结果。
asyncio.create_task(coroutine()) ：在协程中调用，接收另一个协程对象并调度其最终执行，返回的 Task 对象是对协程对象的包装，并且提供控制和查询协程对象运行状态的方法。
await coroutine() ：在协程中调用， await 关键字主动让出执行控制权，终止当前协程执行，直至拿到 coroutine() 的返回结果。同时这也是一个表达式，返回结果即为 coroutine() 返回值。

下面是协程版本旋转指针程序测试效果：

spinner-async

在协程版本中， spinner 是一个 Task 对象，其字符串表示形式为 <Task pending name='Task-2' coro=<spin() running at /Users/jianghushinian/spin/spinner_async.py:8>> 。

根据以上示例代码，我们可以总结出 Python 协程的最大特点：一处异步，处处异步。在协程中任何耗时操作都会减慢事件循环，由于事件循环是单线程管理的，所以这会影响其他所有协程。在编写协程代码，要格外小心，不要写出同步阻塞的代码。好在如今 Python 已经从语法层面原生支持协程，比使用生成器实现协程的年代要好多了。

给你留个小作业：尝试将 slow 协程中 await asyncio.sleep(3) 替换成普通的 time.sleep(3) 观察下效果并思考为什么。

总结

本文我们分别使用了多线程、多进程以及协程这三种不同的并发模型实现了旋转指针程序。三者比较起来，多线程、多进程在语法上差别不大，协程则大为不同，理解起来也更加困难。

由 supervisor 中打印的 spinner 对象结果可以看出，线程对象使用 Thread 来表示，进程对象使用 Process 来表示，协程对象则使用 Task 来表示。协程的定位是用户态线程，相比传统意义上的线程更加轻量，所以叫作 Task 也合理，代表同一个线程下的不同任务。

线程和进程无法在外部终止，即主线程和主进程无法终止由子线程或子进程来执行的 spin 函数，只能通过 Event 来进行通信，然后由 spin 函数内部自己终止。协程则可以通过任务实例方法 Task.cancel() 进行通信， spin 协程中捕获 CancelledError 异常后终止自身代码。

记住，使用协程的代码只有一个执行流，就如同单线程代码，同样只有一个执行流，只不过单线程代码执行流永远是从上到下，而协程的执行流则由事件循环来控制。

多线程和多进程模型是抢占式的，由操作系统进行调度执行。用户通常需要控制的是不要让多个线程（进程）同时操作同一个数据，常使用互斥锁来解决这一问题。而协程只有一个控制循环，协程的控制权在我们自己手里，我们决定什么时候切换其他任务来执行。所以在编写协程代码时，要时刻注意不要写出同步阻塞代码。

本文示例全部出自《流畅的Python（第2版）》一书，这本书的每一小节都值得拿出来单独探讨，我之所以挑选这一主题进行分享，是因为刚好这个主题内容在《流畅的Python（第2版）》中有所升级，如果你阅读过第一版，本文能够很好的展示第二版更新了什么。并发模型是一个宏大的话题，本文只作为入门指引，想要更深入学习，推荐阅读《流畅的Python（第2版）》。

35.从入门到精通：Python CGI编程什么是CGI 网页浏览 CGI架构图 Web服务器支持及配置第一个CGI程序 HTTP头部

Python Tkinter教程（一）——tkinter编程基本步骤、窗口基本属性及Toplevel控件的使用

目标

多线程版

多进程版

协程版

总结