Python 中的进程管理：并行编程基础

并行编程能够让程序在多个处理器或内核上同时执行多个任务，从而更有效地利用处理器资源，缩短处理时间，提升性能。 想象一下，一个复杂问题被分解成多个独立的子问题，每个子问题再细分成更小的任务，然后分配给不同的处理器并行处理，最终显著减少总处理时间。

Python 提供了多种工具和模块支持并行编程。

多进程

multiprocessing 模块允许程序同时运行多个进程，从而充分利用多核处理器的优势，突破全局解释器锁 (GIL) 的限制。

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 密集型任务。 无论选择哪种方式，进程或线程同步都是确保数据一致性和程序正确性的关键。