讲透Python并行编程，极大提升代码效率！

在现代计算中，程序执行速度的优化是提高产品性能和用户体验的重要因素之一。为了充分利用计算机的多核处理器资源，避免资源闲置浪费，开发者常常需要通过并行编程来提升程序运行效率。

Python提供了丰富的并行编程选项：多进程、多线程、协程。每种技术都有其应用场景和优点。本文将分别介绍这三种并行方法，并通过具体代码演示其实现和效果。

如果你在学习Python中明明很认真努力，却依旧学习得很困难。那这时候不禁要思考，你的学习方法是否正确？是在有效学习，还是无效的自我感动？

一、多进程

多进程是操作系统支持的并发执行概念，每个进程有自己独立的内存空间，它们之间的切换由操作系统管理。Python中的multiprocessing模块可以帮助我们创建多个进程来并行处理任务。

import multiprocessing
import os
import time

# 模拟耗时任务
def cpu_bound_task(number):
# print(f”Processing number: {number}”)
time.sleep(1)

if __name__ == ‘__main__’:
# 串行执行
start_time = time.time()
for i in range(5):
cpu_bound_task(i)
end_time = time.time()
print(f”串行执行时间：{end_time – start_time}秒。”) # 假设输出：串行执行时间：5秒。

# 并行执行
start_time_parallel = time.time()
with multiprocessing.Pool(5) as pool:
parallel_results = pool.map(cpu_bound_task, range(5))
end_time_parallel = time.time()
print(f”多进程执行时间：{end_time_parallel – start_time_parallel}秒。”) # 假设输出：多进程执行时间：1秒。

在这个例子里，cpu_bound_task是一个计算任务（我们在第8行设置它每次运行耗时1秒）。在串行执行示例中，任务依次执行，如果每个任务耗时1秒，总共须要5秒。但在下方多进程的执行中，5个任务可以几乎同时执行，在理想情况下，5个任务总共耗时仅约1秒。

代码输出结果如下：

二、多线程

与多进程相比，多线程共享内存空间，上下文切换成本低，适合执行I/O密集型操作。Python中的threading模块提供了多线程编程的实现。

import threading
import time

# 模拟I/O密集型任务
def io_bound_task(number):
# print(f”Thread {number}: Starting”)
time.sleep(1) # 模拟I/O操作，如读写文件
# print(f”Thread {number}: Finished”)

# 串行执行
start_time = time.time()
for i in range(5):
io_bound_task(i)
end_time = time.time()
print(f”串行执行时间：{end_time – start_time}秒。”) # 假设输出：串行执行时间：5秒。

# 多线程执行
start_time_threaded = time.time()
threads = []
for i in range(5):
thread = threading.Thread(target=io_bound_task, args=(i,))
threads.append(thread)
thread.start()

for thread in threads:
thread.join()
end_time_threaded = time.time()
print(f”多线程执行时间：{end_time_threaded – start_time_threaded}秒。”) # 假设输出：多线程执行时间：1秒。

在这个例子中，io_bound_task函数模拟了一个输入/输出操作。线程间切换效率高，因此即便是在全局解释器锁(GIL)存在的情况下，对于I/O密集型任务，多线程也能显著提高效率。

代码输出结果如下：

三、协程

协程是一种用户态的轻量级线程，通过协作式多任务而不是抢占式多任务，减少了切换开销。asyncio是Python用于编写协程程序的库，它利用await语法挂起耗时操作。

import asyncio
import time

# 定义协程函数
async def async_task(number):
# print(f”Task {number}: Started”)
# await 挂起耗时的异步操作
await asyncio.sleep(1)
# print(f”Task {number}: Completed”)

# 串行执行
start_time = time.time()
for i in range(5):
asyncio.run(async_task(i))
end_time = time.time()
print(f”串行执行时间：{end_time – start_time}秒。”) # 假设输出：串行执行时间：5秒。

# 协程并发执行
async def main():
tasks = [async_task(i) for i in range(5)]
await asyncio.gather(*tasks)

start_time_async = time.time()
asyncio.run(main())
end_time_async = time.time()
print(f”协程执行时间：{end_time_async – start_time_async}秒。”) # 假设输出：协程执行时间：1秒。

在如上协程的例子里，async_task是一个异步函数，通过await关键字挂起了耗时操作。在主函数main中并发地运行这些协程，能够在单线程内实现多任务并发。

代码输出结果如下：