Python精选200Tips：106-110

100里python学习之路，现已走过90里，一半了

运行系统：macOS Sonoma 14.6.1
Python编译器：PyCharm 2024.1.4 (Community Edition)
Python版本：3.12

往期链接：

1-5	6-10	11-20	21-30	31-40	41-50

51-60：函数	61-70：类	71-80：编程范式及设计模式

81-90：Python编码规范	91-100：Python自带常用模块-1

101-105：Python自带模块-2

106 multiprocessing: 多进程支持

multiprocessing 模块是 Python 的一个内置模块，用于实现多进程并行处理。与 threading 模块不同，multiprocessing 模块可以充分利用多核 CPU 的优势，使得 CPU 密集型任务能够更高效地执行。主要功能：

• 创建进程: 使用 Process 类可以创建新进程。
• 进程间通信: 提供了多种方式（如队列、管道等）来实现进程间的数据交换。
• 共享内存: 可以共享数据，使用 Value 和 Array。
• 进程池: 使用 Pool 来管理多个进程，简化并行任务的管理。
• 同步机制: 提供锁、信号量等工具来管理进程间的同步。

1. 创建和启动进程

import multiprocessing
import time

def worker(name):
    print(f"Worker {name} starting")
    time.sleep(2)
    print(f"Worker {name} finished")

if __name__ == "__main__":
    processes = []
    for i in range(5):
        process = multiprocessing.Process(target=worker, args=(f"Process-{i}",))
        processes.append(process)
        process.start()

    # 等待所有进程完成
    for process in processes:
        process.join()

    print("All processes finished.")

2. 进程间通信

使用队列 (Queue) 或管道 (Pipe) 实现进程间的消息传递。

import multiprocessing

def worker(queue):
    queue.put("Hello from worker!")

if __name__ == "__main__":
    queue = multiprocessing.Queue()
    process = multiprocessing.Process(target=worker, args=(queue,))
    process.start()
    message = queue.get()  # 从队列中获取消息
    process.join()
    print(f"Received message: {message}")

3. 共享内存

使用共享内存对象（如 Value 和 Array）来在进程间共享数据。

import multiprocessing

def increment(shared_num):
    for _ in range(100):
        shared_num.value += 1

if __name__ == "__main__":
    shared_num = multiprocessing.Value('i', 0)  # 创建一个共享整数
    process = multiprocessing.Process(target=increment, args=(shared_num,))
    process.start()
    process.join()
    print(f"Final value: {shared_num.value}")

4. 共享内存

使用 Pool 类来管理多个进程，简化并行任务的管理。

import multiprocessing
import time

def square(n):
    time.sleep(1)
    return n * n

if __name__ == "__main__":
    numbers = [1, 2, 3, 4, 5]

    with multiprocessing.Pool(processes=4) as pool:
        results = pool.map(square, numbers)

    print(f"Squares: {results}")

5. 同步机制

使用锁 (Lock)、信号量 (Semaphore) 和条件变量 (Condition) 等机制来管理进程间的同步。

import multiprocessing

def worker(lock, shared_counter):
    for _ in range(100):
        with lock:
            shared_counter.value += 1

if __name__ == "__main__":
    lock = multiprocessing.Lock()
    shared_counter = multiprocessing.Value('i', 0)

    processes = []
    for _ in range(2):
        process = multiprocessing.Process(target=worker, args=(lock, shared_counter))
        processes.append(process)
        process.start()

    for process in processes:
        process.join()

    print(f"Final counter value: {shared_counter.value}")

multiprocessing 和 threading 是 Python 中实现并发执行的两个模块，它们各自有不同的特性和适用场景。以下是它们之间的主要区别：

1. 进程与线程

• multiprocessing:
  （1）创建独立的进程，每个进程有自己的内存空间。
  （2）适合 CPU 密集型任务，因为可以充分利用多核 CPU。

• threading:
  （1）创建线程，线程共享同一进程的内存空间。
  （2）适合 I/O 密集型任务，如网络请求、文件操作等，因为线程间的切换比进程更轻便。

2. 资源占用

• multiprocessing:
  进程之间相互独立，因此资源占用较高，启动和销毁