Python多进程编程实战:multiprocessing深度解析

Python并发编程实战:multiprocessing与subprocess模块的深度解析与应用 本文深入解析Python并发编程中的multiprocessing与subprocess模块,帮助开发者突破GIL限制,实现高效并行计算。通过实战案例展示多进程创建、进程间通信及系统命令执行等高级技巧,提升CPU密集型任务处理效率。特别适合需要优化Python性能的开发者。 阅读详情

Python多进程编程实战:multiprocessing深度解析

引言

在Python开发中,多进程编程是提升CPU密集型任务性能的核心技术。作为一名从Rust转向Python的后端开发者,我深刻体会到multiprocessing模块在并行计算方面的优势。multiprocessing是Python标准库中用于多进程编程的模块,提供了强大的并行处理能力。

multiprocessing核心概念

什么是multiprocessing

multiprocessing是Python标准库中用于多进程编程的模块,具有以下特点:

  • 进程创建:支持创建多个子进程
  • 进程通信:支持队列、管道等IPC机制
  • 进程池:支持进程池管理
  • 共享内存:支持进程间共享数据
  • 同步原语:支持锁、信号量等同步机制

架构设计

┌─────────────────────────────────────────────────────────────┐
│                   multiprocessing 架构                    │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐ │
│  │   主进程     │───▶│ 进程管理器   │───▶│   子进程     │ │
│  │ (Main)      │    │ (Manager)    │    │ (Worker)    │ │
│  └──────────────┘    └──────────────┘    └──────────────┘ │
│          │                  │                              │
│          ▼                  ▼                              │
│  ┌──────────────────────────────────────────────────────┐  │
│  │              进程间通信与同步机制                        │  │
│  └──────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

环境搭建与基础配置

基本使用

import multiprocessing

def worker(num):
    print(f"Worker {num} started")
    return num * 2

if __name__ == "__main__":
    processes = []
    
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()

进程池

import multiprocessing

def worker(num):
    return num * 2

if __name__ == "__main__":
    with multiprocessing.Pool(processes=4) as pool:
        results = pool.map(worker, [1, 2, 3, 4, 5])
        print(results)

高级特性实战

进程间通信

import multiprocessing

def producer(queue):
    for i in range(5):
        queue.put(i)
        print(f"Produced: {i}")

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(f"Consumed: {item}")

if __name__ == "__main__":
    queue = multiprocessing.Queue()
    
    p1 = multiprocessing.Process(target=producer, args=(queue,))
    p2 = multiprocessing.Process(target=consumer, args=(queue,))
    
    p1.start()
    p2.start()
    
    p1.join()
    queue.put(None)
    p2.join()

共享内存

import multiprocessing

def update_value(shared_value):
    shared_value.value += 1

if __name__ == "__main__":
    shared_value = multiprocessing.Value('i', 0)
    
    processes = []
    for _ in range(10):
        p = multiprocessing.Process(target=update_value, args=(shared_value,))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()
    
    print(f"Final value: {shared_value.value}")

进程同步

import multiprocessing

def worker(lock, shared_list, index):
    with lock:
        shared_list[index] = f"Worker {index}"

if __name__ == "__main__":
    lock = multiprocessing.Lock()
    manager = multiprocessing.Manager()
    shared_list = manager.list([None] * 5)
    
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(lock, shared_list, i))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()
    
    print(list(shared_list))

实际业务场景

场景一:并行数据处理

import multiprocessing

def process_chunk(chunk):
    return sum(chunk)

def parallel_sum(data, num_processes=4):
    chunk_size = len(data) // num_processes
    chunks = [data[i*chunk_size:(i+1)*chunk_size] for i in range(num_processes)]
    
    with multiprocessing.Pool(processes=num_processes) as pool:
        results = pool.map(process_chunk, chunks)
    
    return sum(results)

if __name__ == "__main__":
    data = list(range(1000000))
    total = parallel_sum(data)
    print(f"Total: {total}")

场景二:并行任务调度

import multiprocessing
import time

def task(name, delay):
    print(f"Task {name} started")
    time.sleep(delay)
    print(f"Task {name} completed")

if __name__ == "__main__":
    tasks = [("A", 2), ("B", 3), ("C", 1), ("D", 4)]
    
    processes = []
    for name, delay in tasks:
        p = multiprocessing.Process(target=task, args=(name, delay))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()
    
    print("All tasks completed")

性能优化

使用进程池

import multiprocessing

def heavy_computation(data):
    return sum(i ** 2 for i in data)

if __name__ == "__main__":
    data_chunks = [range(10000) for _ in range(8)]
    
    with multiprocessing.Pool() as pool:
        results = pool.map(heavy_computation, data_chunks)
    
    print(f"Results: {results}")

异步处理

import multiprocessing

def process_data(data):
    return data * 2

if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        async_results = [pool.apply_async(process_data, (i,)) for i in range(10)]
        results = [ar.get() for ar in async_results]
        print(results)

总结

multiprocessing模块为Python开发者提供了强大的多进程并行处理能力。通过进程池、队列和共享内存等机制,multiprocessing使得CPU密集型任务的并行化变得非常容易。从Rust开发者的角度来看,multiprocessing比Rust的std::process更加高级和易用。

在实际项目中,建议合理使用进程池和队列,并注意进程同步和资源管理。

Windows上的Python多进程 Python Multiprocessing on Windows 因为众所周知的GIL(全局解释器锁),在Python上实现真正的并发只能通过python multiprocessing。但是在Windows上,运用python multiprocessing并没有在Linux那么简单。 if __name__ == "__main__": 也许大家有些在Linux跑的很好的多进程的程序,在Windows上一跑就会经常遇到这些错误的信息 “An attempt has been made to start 阅读详情

相关推荐

Python 并发编程:多进程、多线程、GIL 锁与 ThreadLocal一览

Python 并发编程:多进程、多线程、GIL 锁与 ThreadLocal一览

孤寒者的博客 1万+

python后台——asyncio,多进程+asyncio

今天我们来学习下异步io的服务器处理。

2万+

解密 Python 并发编程:Threading, Multiprocessing 与 Asyncio 深度对比

本文深入对比了Python三大并发编程工具:Threading、Multiprocessing和Asyncio。Threading适合I/O密集型任务但受GIL限制;Multiprocessing能真正并行处理CPU密集型任务但资源消耗大;Asyncio专为高效I/O设计但学习曲线较陡。文章通过代码示例、对比表格和实战场景分析,帮助开发者根据任务类型(计算密集/I/O密集)选择合适工具,并讨论了各自的优缺点及适用场景。最后邀请读者分享并发编程经验和应对GIL限制的见解。

铭渊老黄 383

Flask后端开发中的多线程与多进程处理

本文旨在为Flask开发者提供全面的并发处理指南,涵盖从基础概念到高级优化的所有内容。Flask应用的并发模型选择Python GIL对并发性能的影响线程安全与进程隔离的实现生产环境中的部署策略文章首先介绍并发处理的基本概念,然后深入分析Flask的WSGI实现机制。核心部分将展示多线程和多进程的具体实现,最后讨论生产环境中的最佳实践。: Python Web应用与服务器之间的标准接口: Python解释器的全局锁,限制多线程并行执行Worker: 处理请求的服务进程或线程。

欢迎来到我的优快云空间!这里聚焦AI大模型应用实战,分享前沿技术、实战案例与开发经验。 1406

CATIA二次开发CAA:(一)开发环境搭建

CATIA+CAA+RADE+VS2012

ysm1987的博客 1万+

DeepSeek Harness实战:从零构建插件化AI Agent

AI Agent开发正从硬编码走向框架化组织,插件化架构成为提升工程效率的关键。在构建可复用、可扩展的智能体系统时,开发团队需要一套能够统一管理模型调用、工具注册与上下文组装的基础设施。DeepSeek Harness作为面向Agent工程的插件化框架,通过Harness、DeepAgent与Skill三个核心抽象,将模型、工具与技能解耦为可插拔单元,让开发者无需重复造轮子即可快速搭建具备工具调用能力的智能体。本文从环境配置到Skill插件开发,完整演示如何基于DeepSeek模型构建一个可运行的Agent

weixin_34279184的博客 454

Python 多进程共享内存最佳实践:避开坑、比 multiprocessing.Queue 快 10 倍

Python多进程共享内存高效实践:性能提升10倍+避坑指南 本文针对Python多进程通信的性能瓶颈,对比了multiprocessing.Queue和共享内存两种方案。实测显示,共享内存传输100MB数据耗时仅0.05-0.1秒,比Queue快10倍以上。文章详细讲解了SharedMemory和ShareableList的使用方法,并总结了五大常见问题及解决方案:内存释放、并发安全、名称冲突、数据越界和平台差异。共享内存特别适合大数据传输、高并发计算等场景

网络工程师|十多年企业级运维实战|精通 ‌BGP、OSPF、VLAN、SDN、MPLS、ACL、NetFlow、SNMP、 690

超详细!动态规划详解分析(典型例题分析和对比,附源码)

为啥要使用动态规划?什么时候使用动态规划?以下是我的一些理解和心得,如果你感兴趣,就接着往下看吧。 对您有帮助的话记得给我点个赞哟! 动态规划的基本思想 动态规划(Dynamic Programming,DP)算法通常用于求解某种具有最优性质的问题。在这类问题中,可能会有许多可行解,每一个解都对应一个值,我们希望找到具有最优值的解。 动态规划算法与分治法类似,其基本思想也是将待求解的问题分解成若干个子问题,先求解子问题,然后从这些子问题的解中 得到原有问题的解。与分治法不同的是,动态规划经分解后得到的子问题

qq_44398094的博客 8万+

Python-多进程编程 (multiprocessing 模块)

本文对 Python 的 multiprocessing 模块进行归纳总结,该模块支持多核并行处理,可以提升程序效率。

kusunoki的博客 3114

华大HC32F460从零到200MHz:手把手教你配置时钟系统(附避坑指南)

本文详细解析了华大HC32F460 MCU的时钟系统配置,从启动过程、时钟树分析到实战配置200MHz系统时钟。文章手把手指导开发者如何正确配置外部晶振、MPLL锁相环及总线分频,并提供了硬件检查、代码解读及常见问题排查的避坑指南,帮助用户从零构建稳定可靠的高性能时钟环境。

net55的博客 298

从零开始掌握Python机器学习:七步教程 基础篇

前言 「开始」往往是最难的,尤其是当选择太多的时候,一个人往往很难下定决定做出选择。本教程的目的是帮助几乎没有 Python 机器学习背景的新手成长为知识渊博的实践者,而且这个过程中仅需要使用免费的材料和资源即可。 第一步:基本 Python 技能 如果我们打算利用 Python 来执行机器学习,那么对 Python 有一些基本的了解就是至关重要的。 首先,你需要安装 Python。因为我们后...

hcgx2018的博客 1617

Python 后端开发技术博客专栏 | 第 09 篇 GIL 深度解析与并发编程实战 -- 多线程、多进程、协程的选型

GIL 的本质:GIL 是 CPython 为了保护引用计数线程安全而引入的全局互斥锁。它在 I/O 操作和定时间隔时释放,使得多线程对 I/O 密集型任务有效,但对 CPU 密集型任务无效。Python 3.13 的 Free-threaded 模式是打破这一限制的第一步。多线程(threading):适合 I/O 密集型任务。核心同步原语包括 Lock(互斥锁)、RLock(可重入锁)、Semaphore(信号量)、Event(线程信号)、Condition(条件变量)。是线程安全的数据传递工具。

weixin_43674738的博客 249

利用python求解规划问题

利用python中的cvxpy,sympy,scipy这三个库进行规划问题求解,本文中的例题均来自司守奎老师的python数学建模算法与应用

dashbaani的博客 1万+

深入探究Python多进程编程:Multiprocessing模块基础与实战

在Python编程中,多进程处理是一项关键的技术,特别是在需要处理大规模数据或执行耗时任务时。为了充分利用多核处理器的优势,Python提供了`multiprocessing`模块,使得并行编程变得更加容易。本文将深入探讨`multiprocessing`模块的基础知识,并通过实际代码示例演示其在解决实际问题中的应用。

一键难忘的博客 4297

Matlab基于PSO-MVMD粒子群算法优化多元变分模态分解

Matlab基于PSO-MVMD粒子群算法优化多元变分模态分解

机器学习之心的博客,关注并私信文章链接,获取对应文章源码和数据。 518

MinerU 系列教程 第六课:VLM 后端 - 视觉语言模型的力量

本篇教程将深入 VLM 后端的端到端推理架构。在上一课中我们看到 Pipeline 后端如何用 7+ 个专用模型组成流水线,本课将展示一种截然不同的设计理念 —— 用一个视觉语言模型(VLM)完成所有识别任务。你将了解 6 种推理引擎的选择与配置、MinerUClient 统一接口、二步提取策略,以及 VLM 原始输出如何转换为 MinerU 的标准 Middle JSON 格式。

weixin_43674738的博客 207

pytorch多进程multiprocessing处理视频流

场景: 采用深度学习的方案处理视频流的任务,比如:视频跟踪,视频中的行人检测,车辆检测等其他任务,一般会采用opencv读取视频流,然后再一帧一帧的处理。 问题: 但是在这个过程中由于算力的限制,计算的速度会小于视频帧读取的速度,就是会出现计算结果延时的情况,但是采用cv2.VideoCapture()读取的时候,它会逐帧读取,就是它不是每次读取最新的帧,所以时间久了,这个队列就会溢出,程序就会自...

怡宝2号 9698

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

Python多进程编程实战:彻底突破GIL限制的完整指南

本文深入解析Python多进程编程技术,详细阐述如何通过multiprocessing模块突破GIL限制实现高效并行计算。内容涵盖Process进程管理、Pool进程池优化、Queue/Pipe进程通信等核心组件,结合CPU密集型任务优化案例和分布式数据处理系统实战,提供从基础到高级的完整解决方案。文章包含5个架构流程图和可运行代码示例,帮助开发者掌握多进程性能优化技巧,解决常见问题,并展望未来发展趋势。通过合理运用这些技术,Python程序能够充分发挥多核处理器性能,处理复杂计算任务。

七夜zippoe的博客 1081

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

python mpi4py multiprocessing_python基于multiprocessing的多进程创建方法

《Python爬虫开发与项目实战》——1.4 进程和线程本节书摘来自华章计算机《Python爬虫开发与项目实战》一书中的第1章,第1.4节,作者:范传辉著,更多章节内容可以访问云栖社区“华章计算机”公众号查看1.4 进程和线程在爬虫开发中,进程和线程的概念是非常重要的。提高爬虫的工作效率,打造分布式爬虫,都离不开进程和线程的身影。本节将从多进程...文章华章计算机2017-05-021846浏览量...

weixin_39974400的博客 216

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

python多进程multiprocessing——spawn启动方式解析

spawn这段代码是为了确保多进程程序的稳定性和跨平台兼容性,特别是在涉及 GPU 计算或复杂多线程环境时,通过牺牲一点点启动速度(使用spawn),换取更安全、干净的进程运行环境。

ai领域探索者,欢迎一起交流,目前从事具身智能行业。 847

SciPy 连续分布教程:Mielke Beta-Kappa(Dagum / Burr Type III)分布详解

`scipy.stats.mielke` 是 SciPy 连续概率分布库(`scipy.stats`)中实现的一类"广义 F 分布",具有 `κ`(源码中记作 `k`)与 `θ`(源码中记作 `s`)两个形状参数,支撑集为 `x ≥ 0`。它也被称为 **Dagum 分布**,并等价于一类特殊参数化下的 **Burr Type III 分布**,在降水数据分析与个人收入分布建模等重尾场景中有着经典

gitblog_00326的博客 372

python multiprocessing_python multiprocessing深度解析

在写python多线程代码的时候,会用到multiprocessing这个包,这篇文章总结了一些这个包在多进程管理方面的一些原理和代码分析。1. 问题一:是否需要显式调用pool的close和join方法,不调用的话,子进程是否无法退出?首先初始化Pool的时候,指定processes的个数,就是pool中worker的个数,pool初始化的时候,会把worker以daemon=True的子进程方...

weixin_39882623的博客 255

python多进程之join方法深度解析

#coding=utf-8 ''' python的多进程的理解。熟悉如何创建一个进程。 以及join,start方法的使用。 来说说我们今天的主角,就是multiprocess模块的使用。该模块在windows上面能够模拟出fork的效果 可以实现跨平台,因此都是用multiprocessing 下面还是来直接看看代码吧。 ''' from multiprocessing import Process  import os  import time  import r...

yimenglin的博客 1081

多进程模块:multiprocessing

多进程: (1) 前面我们学习的多线程,其实算不上真正的多线程,即使你开了很多个线程,在同一时间内只能有一个CPU核数来处理一个线程(2)在 python 中,多进程算得上是真正的多线程,假设你的CPU有四核,如果开四个子进程,四个CPU核数会同时处理这四个子进程(3)在 threading 中,我们是通过 threading.Thread(target=function, args=(.....

weixin_30338481的博客 103

【Python多进程编程必知】:Manager字典锁机制深度解析与性能优化策略

掌握多进程 Manager 的字典锁机制,有效解决Python多进程间数据共享与同步难题。适用于高并发场景,通过Manager实现进程安全的字典操作,兼顾灵活性与可靠性。深入剖析底层原理与性能优化策略,提升程序效率。值得收藏,点击了解实战技巧。

VarLens的博客 522
上一篇: Rust加密哈希实战:sha2深度解析
下一篇: Rust宏编程实战:深度解析与最佳实践
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值