并行编程能够让程序在多个处理器或内核上同时执行多个任务，从而更有效地利用处理器资源，缩短处理时间，提升性能。 想象一下，一个复杂问题被分解成多个独立的子问题，每个子问题再细分成更小的任务，然后分配给不同的处理器并行处理，最终显著减少总处理时间。
Python 提供了多种工具和模块支持并行编程。
多进程
multiprocessing 模块允许程序同时运行多个进程，从而充分利用多核处理器的优势，突破全局解释器锁 (GIL) 的限制。
立即学习“Python免费学习笔记（深入）”；
GIL 是 CPython 解释器中的一种机制，它限制了同一时刻只有一个线程执行 Python 字节码，从而限制了多线程在 CPU 密集型任务中的并行性。
示例：平方和立方计算
from multiprocessing import Process
def calculate_square(numbers):
for n in numbers:
print(f"{n}的平方是: {n * n}")
def calculate_cube(numbers):
for n in numbers:
print(f"{n}的立方是: {n * n * n}")
if __name__ == "__main__":
numbers = [1, 2, 3, 4]
p1 = Process(target=calculate_square, args=(numbers,))
p2 = Process(target=calculate_cube, args=(numbers,))
p1.start()
p2.start()
p1.join()
p2.join()
多进程的优势类似于多个厨师同时在厨房准备不同菜肴，相比单一厨师依次烹饪，效率大大提升。
进程间数据共享
Python 的 multiprocessing 模块提供了多种进程间共享数据的方法，但需要注意的是每个进程拥有独立的内存空间。
-
共享内存:
Value和Array对象用于共享单一数据类型和数据数组。
from multiprocessing import Process, Value
def increment_counter(shared_counter):
for _ in range(1000):
shared_counter.value += 1
if __name__ == "__main__":
counter = Value('i', 0)
processes = [Process(target=increment_counter, args=(counter,)) for _ in range(5)]
for p in processes:
p.start()
for p in processes:
p.join()
print(f"最终计数器值: {counter.value}")
- 队列: 使用 FIFO (先进先出) 结构在进程间传递数据。
from multiprocessing import Process, Queue
def producer(queue):
for i in range(5):
queue.put(i)
print(f"生产者生产: {i}")
def consumer(queue):
while not queue.empty():
item = queue.get()
print(f"消费者消费: {item}")
if __name__ == "__main__":
q = Queue()
p1 = Process(target=producer, args=(q,))
p2 = Process(target=consumer, args=(q,))
p1.start()
p2.start()
p1.join()
p2.join()
- 管道: 提供进程间双向数据传输。
from multiprocessing import Process, Pipe
def send_data(conn):
conn.send([1, 2, 3, 4])
conn.close()
if __name__ == "__main__":
parent_conn, child_conn = Pipe()
p = Process(target=send_data, args=(child_conn,))
p.start()
print(f"接收到的数据: {parent_conn.recv()}")
p.join()
进程间填充与同步
进程间填充主要用于解决内存组织和数据访问冲突问题，尤其是在缓存行错误共享的情况下。 进程同步则使用诸如锁 (Lock) 等机制来保证数据一致性，避免竞争条件。
from multiprocessing import Process, Lock
def print_numbers(lock, name):
with lock:
for i in range(5):
print(f"{name}: {i}")
if __name__ == "__main__":
lock = Lock()
processes = [Process(target=print_numbers, args=(lock, f"进程 {i}")) for i in range(3)]
for p in processes:
p.start()
for p in processes:
p.join()
多线程
多线程允许在同一进程中同时运行多个线程，共享资源，适合 I/O 密集型任务。 但由于 GIL 的存在，在 CPU 密集型任务中性能提升有限。 threading 模块用于创建和管理线程。 线程同步机制与多进程类似，也需要使用锁等工具来避免数据竞争。
示例：线程计数器
import threading
counter = 0
lock = threading.Lock()
def increment():
global counter
for _ in range(100000):
with lock:
counter += 1
threads = [threading.Thread(target=increment) for _ in range(5)]
for t in threads:
t.start()
for t in threads:
t.join()
print(f"最终计数器值: {counter}")
结论
选择多进程还是多线程取决于具体任务的特性。 多进程更适合 CPU 密集型任务，而多线程更适合 I/O 密集型任务。 无论选择哪种方式，进程或线程同步都是确保数据一致性和程序正确性的关键。
