Python 进程基础

multiprocessing 模块实现多进程编程，每个进程有独立内存空间。

创建进程

import multiprocessing
import time

def worker(name):
    print(f"进程 {name} 开始，PID: {multiprocessing.current_process().pid}")
    time.sleep(2)
    print(f"进程 {name} 结束")

# 方式一：函数创建
p = multiprocessing.Process(target=worker, args=('A',))
p.start()
p.join()

# 方式二：类继承
class MyProcess(multiprocessing.Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(f"进程 {self.name} 运行")

p2 = MyProcess('B')
p2.start()
p2.join()

进程属性

import multiprocessing
import time

def task():
    time.sleep(3)

p = multiprocessing.Process(target=task)

print(p.name)       # Process-1
print(p.pid)        # None（启动前）
print(p.is_alive()) # False

p.start()

print(p.pid)        # 进程ID（数字）
print(p.is_alive()) # True

p.join()
print(p.is_alive()) # False

进程间通信 Queue

import multiprocessing

def producer(q):
    for i in range(5):
        q.put(i)
        print(f"生产: {i}")

def consumer(q):
    while True:
        item = q.get()
        print(f"消费: {item}")
        if item == 4:
            break

q = multiprocessing.Queue()

p1 = multiprocessing.Process(target=producer, args=(q,))
p2 = multiprocessing.Process(target=consumer, args=(q,))

p1.start()
p2.start()

p1.join()
p2.join()

进程间通信 Pipe

import multiprocessing

def sender(conn):
    conn.send('Hello from sender')
    conn.close()

def receiver(conn):
    msg = conn.recv()
    print(f"收到: {msg}")
    conn.close()

# 创建管道，返回两个连接对象
parent_conn, child_conn = multiprocessing.Pipe()

p1 = multiprocessing.Process(target=sender, args=(child_conn,))
p2 = multiprocessing.Process(target=receiver, args=(parent_conn,))

p1.start()
p2.start()

p1.join()
p2.join()

共享内存 Value 和 Array

import multiprocessing

def increment(counter):
    for _ in range(1000):
        counter.value += 1

# 共享整数
counter = multiprocessing.Value('i', 0)  # 'i' = 整数类型

processes = [multiprocessing.Process(target=increment, args=(counter,))
             for _ in range(10)]

for p in processes:
    p.start()
for p in processes:
    p.join()

print(counter.value)  # 结果可能不等于 10000（需要加锁）

# 使用锁
def safe_increment(counter, lock):
    for _ in range(1000):
        with lock:
            counter.value += 1

lock = multiprocessing.Lock()
counter = multiprocessing.Value('i', 0)

processes = [multiprocessing.Process(target=safe_increment, args=(counter, lock))
             for _ in range(10)]

for p in processes:
    p.start()
for p in processes:
    p.join()

print(counter.value)  # 10000（正确）

共享数组

import multiprocessing

def modify_array(arr):
    for i in range(len(arr)):
        arr[i] = arr[i] * 2

# 共享数组
arr = multiprocessing.Array('i', [1, 2, 3, 4, 5])

p = multiprocessing.Process(target=modify_array, args=(arr,))
p.start()
p.join()

print(list(arr))  # [2, 4, 6, 8, 10]

Manager 共享对象

import multiprocessing

def modify_dict(d, lst):
    d['key'] = 'value'
    lst.append(123)

with multiprocessing.Manager() as manager:
    shared_dict = manager.dict()
    shared_list = manager.list()

    p = multiprocessing.Process(target=modify_dict, args=(shared_dict, shared_list))
    p.start()
    p.join()

    print(shared_dict)  # {'key': 'value'}
    print(shared_list)  # [123]

进程启动方法

import multiprocessing

# 查看可用启动方法
print(multiprocessing.get_all_start_methods())
# ['spawn', 'fork', 'forkserver']

# 设置启动方法
multiprocessing.set_start_method('spawn')  # Windows 默认

# 获取当前方法
print(multiprocessing.get_start_method())

进程方法对比

要点总结

• Process 创建进程，参数与 Thread 类似
• 进程有独立内存空间，绕过 GIL
• Queue 和 Pipe 实现进程间通信
• Value 和 Array 实现共享内存
• Manager 提供更灵活的共享对象
• Windows 使用 spawn，Unix 可用 fork
• 进程适合 CPU 密集型并行任务