实现好的程序效果如下：

这有点像下载进度条，因为打印旋转指针和耗时任务是“同时”进行的，这种场景只能通过并发模型来实现。

我们将分别使用多线程、多进程以及协程来实现这个程序，以此来演示 Python 的的并发模型用法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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 两个函数，完成这个旋转指针程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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(Thread-1, initial)> ，其中 Thread-1 是线程名称， initial 是线程状态，表示当前线程刚初始化完成，尚未启动。

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

1
2
3
4
5
6

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 函数也要稍作修改：

1
2
3
4
5
6
7
8
9

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 name='Process-1' parent=94367 initial> ，进程名称为 Process-1 ， parent 代表父进程 ID 为 94367 （即主进程 ID）， initial 是进程状态，表示当前进程刚初始化完成，尚未启动。