在Python中，multiprocessing 模块提供了强大的多进程支持，能够帮助我们充分利用多核CPU资源来实现并行计算。相比传统的多线程模式，Python的多进程模式更加高效，因为它可以避免Python的全局解释器锁（GIL）对并发性能的限制。

为什么选择多进程？

Python的多线程模式受限于全局解释器锁（GIL），在处理CPU密集型任务时，多线程的并发效率会受到较大影响。而多进程模式通过为每个进程分配独立的内存空间，允许程序在多个CPU核上并行执行任务，能够显著提升CPU密集型任务的执行效率。

使用multiprocessing 模块，可以：

• 创建独立的进程来执行任务，每个进程拥有独立的内存空间。

• 在多个进程间共享数据或进行通信。

• 通过进程池实现任务的并行执行。

• 这里插播一条粉丝福利，如果你正在学习Python或者有计划学习Python，想要突破自我，对未来十分迷茫的，可以点击这里获取最新的Python学习资料和学习路线规划（免费分享，记得关注）

创建和启动进程

在multiprocessing模块中，Process类用于创建和管理进程。每个进程都有自己的内存空间和全局变量，因此进程之间不会互相干扰。

创建一个简单的进程

import multiprocessing
import time

# 定义任务函数
def worker():
    print("任务开始执行")
    time.sleep(2)  # 模拟任务耗时
    print("任务结束")

if __name__ == "__main__":
    # 创建进程
    process = multiprocessing.Process(target=worker)
    
    # 启动进程
    process.start()
    
    # 等待进程执行完毕
    process.join()

在这个示例中，通过 multiprocessing.Process 创建了一个新的进程，并通过 start() 启动进程。join() 方法会阻塞主进程，直到子进程执行完毕。

多个进程并行执行

import multiprocessing
import time

def worker(number):
    print(f"任务{number}开始执行")
    time.sleep(2)
    print(f"任务{number}结束")

if __name__ == "__main__":
    # 创建多个进程
    processes = []
    for i in range(5):
        process = multiprocessing.Process(target=worker, args=(i,))
        processes.append(process)
        process.start()
    
    # 等待所有进程执行完毕
    for process in processes:
        process.join()

在这个示例中，启动了5个进程，每个进程并行执行各自的任务，主进程通过 join() 等待所有子进程完成。

进程间通信

在多进程编程中，进程间的通信是一个关键问题。由于每个进程都有自己独立的内存空间，无法像线程一样直接共享数据。multiprocessing模块提供了多种进程间通信的方式，包括Queue、Pipe、Manager等。

使用Queue进行进程间通信

Queue 是一种先进先出（FIFO）的数据结构，可以在多个进程之间安全地传递数据。

import multiprocessing

# 定义任务函数
def worker(q):
    q.put("任务完成")

if __name__ == "__main__":
    # 创建队列
    q = multiprocessing.Queue()

    # 创建进程并传入队列
    process = multiprocessing.Process(target=worker, args=(q,))
    process.start()
    process.join()

    # 从队列中获取数据
    result = q.get()
    print(result)

在这个示例中，子进程通过 q.put() 向队列中放入数据，主进程通过 q.get() 获取队列中的数据，实现了进程间的数据传递。

使用Pipe进行进程间通信

Pipe 是另一种进程间通信方式，它提供了一个双向的通信通道，适合在两个进程之间传递数据。

import multiprocessing

# 定义任务函数
def worker(conn):
    conn.send("来自子进程的消息")
    conn.close()

if __name__ == "__main__":
    # 创建管道
    parent_conn, child_conn = multiprocessing.Pipe()

    # 创建进程并传入管道的一端
    process = multiprocessing.Process(target=worker, args=(child_conn,))
    process.start()
    process.join()

    # 从管道另一端接收数据
    print(parent_conn.recv())

在这个示例中，使用 Pipe 实现了父子进程之间的双向通信。

进程池（Pool）

在某些场景中，需要并发执行大量的任务，而直接创建大量进程可能会导致系统资源耗尽。multiprocessing模块中的Pool类提供了一种管理多个进程的方式，通过进程池可以限制同时运行的进程数量，避免资源浪费。

使用Pool并发执行任务

import multiprocessing
import time

# 定义任务函数
def worker(number):
    print(f"任务{number}开始执行")
    time.sleep(2)
    print(f"任务{number}结束")

if __name__ == "__main__":
    # 创建进程池，最多允许3个进程同时运行
    with multiprocessing.Pool(3) as pool:
        pool.map(worker, range(5))

在这个示例中，Pool 创建了一个包含3个进程的进程池，map() 方法将任务分发给进程池中的进程并行执行。每个任务最多允许3个进程同时运行，其余任务会等待空闲进程。

异步任务执行

Pool.apply_async() 方法可以异步地提交任务，并通过回调函数处理结果。

import multiprocessing
import time

# 定义任务函数
def worker(number):
    time.sleep(2)
    return f"任务{number}完成"

# 定义回调函数
def callback(result):
    print(result)

if __name__ == "__main__":
    # 创建进程池
    with multiprocessing.Pool(3) as pool:
        for i in range(5):
            pool.apply_async(worker, args=(i,), callback=callback)

        # 等待所有任务完成
        pool.close()
        pool.join()

在这个示例中，apply_async() 提交任务后立即返回，主进程不会阻塞。任务执行完毕后，通过回调函数输出结果。

进程同步

由于多个进程在并发执行时，它们对共享资源的访问是无序的。因此，进程同步是保证数据一致性的重要手段。multiprocessing 模块提供了 Lock、Semaphore 等同步机制。

使用Lock保证进程同步

import multiprocessing
import time

# 定义任务函数
def worker(lock, number):
    with lock:  # 获取锁
        print(f"任务{number}开始")
        time.sleep(2)
        print(f"任务{number}结束")

if __name__ == "__main__":
    lock = multiprocessing.Lock()

    # 创建多个进程
    processes = []
    for i in range(5):
        process = multiprocessing.Process(target=worker, args=(lock, i))
        processes.append(process)
        process.start()

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

在这个示例中，Lock 用于确保同时只有一个进程可以执行受保护的代码块，防止进程之间的数据竞争。

共享内存

Python的multiprocessing模块还支持在进程间共享数据，Value 和 Array 类可以用于在进程间共享内存，避免复制数据。

使用Value和Array共享数据

import multiprocessing

# 定义任务函数
def worker(shared_value, shared_array):
    shared_value.value += 1
    for i in range(len(shared_array)):
        shared_array[i] += 1

if __name__ == "__main__":
    shared_value = multiprocessing.Value('i', 0)  # 共享整数
    shared_array = multiprocessing.Array('i', [1, 2, 3, 4, 5])  # 共享数组

    processes = []
    for _ in range(3):
        process = multiprocessing.Process(target=worker, args=(shared_value, shared_array))
        processes.append(process)
        process.start()

    for process in processes:
        process.join()

    print("共享值：", shared_value.value)
    print("共享数组：", shared_array[:])

在这个示例中，Value 和 Array 用于在多个进程间共享数据。每个进程都会对共享的数据进行修改，修改后的结果会反映在所有进程中。

总结

multiprocessing 模块是Python提供的多进程支持，旨在帮助开发者充分利用多核CPU资源，提升并发任务的执行效率。相比于受限于全局解释器锁（GIL）的多线程，multiprocessing 通过创建独立进程并分配各自的内存空间，避免了线程切换带来的性能瓶颈。本文详细介绍了如何使用 multiprocessing 创建和管理进程、进程间通信、进程池以及同步机制。通过掌握这些功能，开发者可以在处理CPU密集型任务时实现更高效的并行计算，提高程序的性能和扩展性。在需要执行大量并发任务的场景中，multiprocessing 是一个强大而灵活的工具。

最后，我精心筹备了一份全面的Python学习大礼包，完全免费分享给每一位渴望成长、希望突破自我现状却略感迷茫的朋友。无论您是编程新手还是希望深化技能的开发者，都欢迎加入我们的学习之旅，共同交流进步！

🌟 学习大礼包包含内容：

Python全领域学习路线图：一目了然，指引您从基础到进阶，再到专业领域的每一步学习路径，明确各方向的核心知识点。

超百节Python精品视频课程：涵盖Python编程的必备基础知识、高效爬虫技术、以及深入的数据分析技能，让您技能全面升级。

实战案例集锦：精选超过100个实战项目案例，从理论到实践，让您在解决实际问题的过程中，深化理解，提升编程能力。

华为独家Python漫画教程：创新学习方式，以轻松幽默的漫画形式，让您随时随地，利用碎片时间也能高效学习Python。

互联网企业Python面试真题集：精选历年知名互联网企业面试真题，助您提前备战，面试准备更充分，职场晋升更顺利。

👉 立即领取方式：只需【点击这里】，即刻解锁您的Python学习新篇章！让我们携手并进，在编程的海洋里探索无限可能！