Python 中并发方面的差异

---

考虑到Python 3发布后有关异步操作和并发性的新趋势，有些人可能会认为Python刚刚引入了这些概念或功能。

许多新手可能会认为使用asyncio是执行并发和异步任务的唯一实用方法。本文将讨论如何在Python中实现并发以及其优点和缺点。

---

线程和多线程

线程在Python中已经存在很长时间了。因此，我们可以通过线程同时执行多个操作。

不幸的是，CPython（典型的主流Python版本）仍然使用全局解释器锁（GIL），这使得多线程应用（目前常用的实现并行处理的方法）不太理想。

Python引入了GIL来使CPython的内存处理更加可管理，以便与C（例如扩展）进行集成。

GIL是一种锁定机制，Python解释器一次只能运行一个线程。Python的字节码只能由一个线程同时执行。

示例代码：

import threading
import time
import random

def worker(num):
    sec = random.randrange(1, 5)
    time.sleep(sec)
    print("I am thread {}, who slept for {} seconds.".format(num, sec))

for i in range(3):
    t = threading.Thread(target=worker, args=(i,))
    t.start()

print("Completed!")

在上面的代码中，我们定义了一个名为 worker(num) 的函数，它接收一个参数num。worker函数会随机休眠一段时间，然后打印出休眠的秒数和线程的编号。

我们使用threading.Thread类创建了三个线程对象，并通过 target 参数指定了要执行的函数 worker，并通过 args 参数传递了参数i。然后，我们使用 .start() 方法启动这些线程。

以下是上述代码的输出：

Completed!
I am thread 1, who slept for 3 seconds.
I am thread 3, who slept for 2 seconds.
I am thread 4, who slept for 4 seconds.

---

进程和多进程

多进程利用多个CPU。由于每个CPU并行运行，我们可以有效地同时执行多个任务。对于CPU密集型任务，多进程是您想要使用的方法。

Python引入了multiprocessing模块来实现并行处理，如果您使用过线程，它会感觉非常相似。

示例代码：

import multiprocessing
import time
import random

def worker(num):
    sec = random.randrange(1, 5)
    time.sleep(sec)
    print("I am process {}, who slept for {} seconds.".format(num, sec))

for i in range(3):
    t = multiprocessing.Process(target=worker, args=(i,))
    t.start()

print("Completed")

与多线程不同，我们使用多个在CPU的不同核心上运行的进程，这使得Python脚本更快。

以下是上述代码的输出：

Completed
I am process 1, who slept for 1 seconds.
I am process 2, who slept for 2 seconds.
I am process 0, who slept for 3 seconds.

---

异步和asyncio

在同步操作中，任务按顺序进行，一个接一个地执行。然而，在异步操作中，任务可以完全独立于其他任务而开始执行。

异步任务可能会启动并继续运行，而执行会切换到另一个任务。另外，异步任务通常在后台执行，不会阻塞（即不会使程序等待完成）。

除了其他有价值的功能，asyncio提供了一个事件循环（event loop）。事件循环监视各种I/O事件，切换到准备就绪的任务，并暂停等待I/O的任务。

因此，我们不会浪费时间在未完成的任务上。

示例代码：

import asyncio
import datetime
import random

async def my_sleep_func():
    await asyncio.sleep(random.randint(0, 5))

async def displayDate(num, loop):
    endTime = loop.time() + 60.0
    while True:
        print("Loop: {} Time: {}".format(num, datetime.datetime.now()))
        if (loop.time() + 1.0) >= endTime:
            break
        await my_sleep_func()


loop = asyncio.get_event_loop()

asyncio.ensure_future(displayDate(1, loop))
asyncio.ensure_future(displayDate(2, loop))

loop.run_forever()

在上面的代码片段中，我们定义了一个名为displayDate的异步函数，它接收一个数字和事件循环作为参数。该函数包含一个无限循环，在60秒后停止。在这60秒内，它重复打印时间并进行休眠。

await 函数可以等待其他异步函数完成。

我们使用 asyncio.ensure_future 函数将函数传递给事件循环。

然后，我们开始运行事件循环。当遇到await调用时，asyncio会意识到函数可能需要一些时间。当asyncio注意到暂停的函数的I/O准备就绪时，它会恢复执行。

现在，关键是在这三种并发形式中我们需要使用哪一种？我们可以考虑以下几点来帮助做决策：

• 对于CPU密集型操作，请使用多进程。
• 对于I/O密集型、快速I/O和连接数量有限的情况，请使用多线程。
• 对于I/O密集型、慢速I/O和大量连接的情况，请使用异步I/O。
• asyncio/await适用于Python 3.5及更高版本。

我们还可以参考下面的伪代码来做决策：

if io_bound:
    if io_very_slow:
        print("Use asyncio")
    else:
        print("Use multithreading")
else:
    print("Use multiprocessing")