【Python】Python多进程详解

已于 2024-01-05 16:47:42 修改
阅读量5.8k 收藏 139
点赞数 24
分类专栏： python python入门 文章标签： Python入门 python python多进程
于 2022-12-06 10:32:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59162248/article/details/128198400
版权

1. 什么进程？

进程（Process），顾名思义，就是进行中的程序。有一句话说得好：程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体。进程是资源分配的最小单元，也就是说每个进程都有其单独的内存空间。

2. 如何创建一个进程？

Unix/Linux系统通过fork系统调用创建一个进程，但是在Windows中并没有fork调用。但是别担心，Python中内置的multiprocessing模块是跨平台的，我们可以通过对multiprocess模块中的Process类进行实例化创建一个进程对象，如：

import os
from multiprocessing import Process

def run_a_sub_proc(name):
    print(f'子进程：{name}（{os.getpid()}）开始...')

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    # 通过对Process类进行实例化创建一个子进程
    p = Process(target=run_a_sub_proc, args=('测试进程', ))
    p.start()
    p.join()

执行结果如下：
在这里插入图片描述
创建一个子进程

这里需要明确以下主进程和子进程。当我们通过python demo.py开始执行demo.py这个程序时，程序被赋予了声明，成为一个进程，这个进程是主进程。而在主进程执行过程，通过对Process类进行实例化创建的是子进程。

3. multiprocessing基本功能

3.1 进程启动

当通过对Process类实例化获得一个进程p以后，直接通过p.start()就可以启动该进程了。可是，在start()方法的背后，实际上有三种启动方法：

  • spawn：子进程仅继承有限的资源，适用于Unix/Linux和Windows
  • fork：子进程会继承父进程中所有的资源，仅适用于Unix/Linux
  • forkserver：创建一个单进程的服务进程，专门用来处理子进程的创建，仅适用于Unix/Linux[1]
    在这里插入图片描述
    在这里插入图片描述
    目前，对于Unix/Linux，默认的启动方法是fork；而对于Windows和MacOS系统，默认的启动方法是spawn。

3.2 join()方法

在多线程中，join()方法会使主线程进入阻塞，直到调用join()方法的子线程执行完毕。那么在多进程中，join()方法的用法是一样，即使主进程进入阻塞，直到调用join()方法的子进程执行完毕。猜猜以下两个例子的运行结果会有什么不同？

# 例一
import os, time
from multiprocessing import Process

def run_a_sub_proc(name):
    print(f'子进程：{name}（{os.getpid()}）开始...')
    for i in range(3):
        print(f'子进程：{name}（{os.getpid()}）运行中...')
        time.sleep(1)

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    p1 = Process(target=run_a_sub_proc, args=('进程-1', ))
    p2 = Process(target=run_a_sub_proc, args=('进程-2', ))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

# 例二
import os, time
from multiprocessing import Process

def run_a_sub_proc(name):
    print(f'子进程：{name}（{os.getpid()}）开始...')
    for i in range(3):
        print(f'子进程：{name}（{os.getpid()}）运行中...')
        time.sleep(1)

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    p1 = Process(target=run_a_sub_proc, args=('进程-1', ))
    p2 = Process(target=run_a_sub_proc, args=('进程-2', ))
    p1.start()
    p1.join()
    p2.start()
    p2.join()

执行结果：
在这里插入图片描述
通过join方法阻塞主进程

简而言之，join()方法就是让主进程进入阻塞状态，等对应的子进程执行完毕再执行下一行，主要用于进程同步。

3.3 Pool

如果想一次性创建多个进程，可以用Pool方法（注意Pool是一个方法，不是类），如

import os, time
from multiprocessing import Process, Pool

def run_a_sub_proc(name):
    print(f'子进程：{name}（{os.getpid()}）开始！')
    for i in range(2):
        print(f'子进程：{name}（{os.getpid()}）运行中...')
        time.sleep(1)
    print(f'子进程：{name}（{os.getpid()}）结束！')

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    p = Pool(3)
    for i in range(1, 5):
        p.apply_async(run_a_sub_proc, args=(f"进程-{i}",))
    p.close()
    p.join()

运行结果如下
在这里插入图片描述
进程1~3结束了进程4才开始

值得注意的是，在上述代码中，进程1~3结束了进程4才开始，这是为什么呢？这是因为在p=Pool(3)中定义了每次执行的子进程个数的限制。

Pool的默认大小是你所用的电脑CPU的核数，CPU核数可通过os.cpu_count()获得。

p.join()的意思是等Pool中所有的子进程全部执行完毕再进行下一步，在调用p.join()之前需要先调用p.close()。

4 进程间通信

现在设想你需要两个进程，一个进程（接收进程）产生数据（比如从网站上爬虫，或者从websocket接收数据等），另一个进程（转发进程）对产生的数据进行处理并转发（比如计算并处理之后上传数据库，或者发送给websocket等）。这是一个非常常见的应用场景，如何把接收进程接受的数据传递给转发进程呢？直接硬写是不行的，比如下面这个错误示范

import os, time, random
from multiprocessing import Process

data: int

def recv():
    print(f'子进程：接收进程（{os.getpid()}）开始！')
    while True:
        global data
        # 用产生随机数的方法模拟数据的接收
        data = random.randint(1, 100)
        print(f'子进程：接收进程接收到数据{data}！')
        sleep_time = random.randint(1, 3)
        time.sleep(sleep_time)

def send():
    print(f'子进程：转发进程（{os.getpid()}）开始！')
    while True:
        global data
        print(f'子进程：转发进程接收到数据{data}并开始处理、转发！')

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    p1 = Process(target=recv)
    p2 = Process(target=send)
    p1.start()
    p2.start()
    p1.join()
    p2.join()

上面这个程序毫无疑问是会报错的，即便你声明了数据data是全局变量。
在这里插入图片描述
程序报错

报错的原因是：每个子进程享有独立的内存空间，接收进程产生的数据不能马上同步到转发进程中，这也就是为什么接收线程中提示“name ‘data’ is not defined”的原因。

那如何实现进程间通信呢？multiprocessing提供了两种方法：Queue和Pipe。

4.1 Queue

import os, time, random
from multiprocessing import Process, Queue

def recv(q):
    print(f'子进程：接收进程（{os.getpid()}）开始！')
    while True:
        # 用产生随机数的方法模拟数据的接收
        data = random.randint(1, 100)
        print(f'子进程：接收进程接收到数据{data}！')
        q.put(data)
        sleep_time = random.randint(1, 3)
        time.sleep(sleep_time)

def send(q):
    print(f'子进程：转发进程（{os.getpid()}）开始！')
    while True:
        # 注意：如果q里面没有数据，get()方法就会等待，直到获得一个数据并赋值给data
        data = q.get()
        print(f'子进程：转发进程接收到数据{data}并开始处理、转发！')
        time.sleep(1)

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    q = Queue()
    p1 = Process(target=recv, args=(q,))
    p2 = Process(target=send, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

执行结果如下
在这里插入图片描述
通过Queue实现进程间通信

需要注意两点：

  • data=q.get()过程中，如果q中没有数据，并不是返回一个None给data，get()方法会进入等待状态，直到q中有数据为止；
  • queue是先进先出（FIFO）的。

4.2 Pipe

如果你创建了很多个子进程，那么其中任何一个子进程都可以对Queue进行存（put）和取（get）。但Pipe不一样，Pipe只提供两个端点，只允许两个子进程进行存（send）和取（recv）。也就是说，Pipe实现了两个子进程之间的通信。

import os, time, random
from multiprocessing import Pipe, Process

def sub_process(name, p):
    print(f'子进程：{name}（{os.getpid()}）开始！')
    while True:
        data_s = random.randint(1, 100)
        p.send(data_s)
        print(f'子进程：{name}发送数据：{data_s}！')
        data_r = p.recv()
        print(f'子进程：{name}接收到数据：{data_r}！')
        time.sleep(1)

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    conn_1, conn_2 = Pipe()
    p1 = Process(target=sub_process, args=("进程-1", conn_1,))
    p2 = Process(target=sub_process, args=("进程-2", conn_2,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

执行结果
在这里插入图片描述
通过Pipe实现进程间通信

注意：

  • Queue可以被多个进程调用，而Pipe只能被两个进程调用；
  • Queue是基于Pipe实现的，因此Pipe速度比Queue快很多[2]。

5.进程间数据共享

通常不鼓励进程间数据共享，因为可能会带来“竞争危害”、产生不可预知的结果。但如果有这方面的需要，在保证数据安全的基础上也是可以的。实现线程间数据共享主要有两种方法：Value/Array和Manager

5.1 Value/Array

import os, time, random
from multiprocessing import Process, Value, Array

def sub_process(name, v, arr):
    print(f'子进程：{name}（{os.getpid()}）开始！')
    while True:
        if name == "修改Value":
            v.value += 1            # 通过Value.value读取Value的数值
        else:
            num = random.randint(0, 2)
            arr[num] += 1
        print(f'子进程：{name}', v.value, arr[:])
        time.sleep(random.randint(1, 3))

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    v = Value("i", 0)               # i 指整数
    arr = Array("i", [1, 2, 3])     # i 指整数型组成的数组
    p1 = Process(target=sub_process, args=("修改Value", v, arr, ))
    p2 = Process(target=sub_process, args=("修改Array", v, arr, ))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

执行结果：
在这里插入图片描述
通过两个子线程对数值和数组不断进行修改

5.2 Manager

Manager()方法会返回一个服务进程，这个进程专门用来维护进程间数据的共享。Manager提供的数据格式非常多，包括list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array等。

6. 进程同步

在前面提到，不鼓励在进程间实现数据共享，因为容易产生竞争危害。例如两个线程，分别对同一个数值不断地进行+1，循环200遍，那么理论上最终这个数值会变成400，然而事实并非如此，如

import os, time, random
from multiprocessing import Process, Value

def sub_process(name, v):
    print(f'子进程：{name}（{os.getpid()}）开始！')
    for i in range(200):
        v.value += 1

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    v = Value("i", 0)               # i 指整数
    p1 = Process(target=sub_process, args=("进程-1", v,))
    p2 = Process(target=sub_process, args=("进程-2", v,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(v.value)

执行结果如下：数值并不是400，因为发生了竞争危害。
在这里插入图片描述
最终数值并不是400

解决该问题的办法就是加进程锁。

import os, time, random
from multiprocessing import Process, Value, Lock

def sub_process(name, v, lock):
    print(f'子进程：{name}（{os.getpid()}）开始！')
    for i in range(200):
        lock.acquire()
        v.value += 1
        lock.release()

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    v = Value("i", 0)               # i 指整数
    lock = Lock()
    p1 = Process(target=sub_process, args=("进程-1", v, lock))
    p2 = Process(target=sub_process, args=("进程-2", v, lock))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(v.value)

输出结果变成了预期的400：
在这里插入图片描述

最后

在学习python中有任何困难不懂的可以微信扫描下方CSDN官方认证二维码加入python交流学习
多多交流问题，互帮互助，这里有不错的学习教程和开发工具。
（python兼职资源+python全套学习资料）

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
在这里插入图片描述

二、Python必备开发工具

在这里插入图片描述

四、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
在这里插入图片描述

五、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。在这里插入图片描述

六、Python练习题

检查学习结果。
在这里插入图片描述

七、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
在这里插入图片描述
在这里插入图片描述
最后，千万别辜负自己当时开始的一腔热血，一起变强大变优秀。

Python程序员小泉
关注
专栏目录
Python multiprocess模块(上)
m0_38011792的博客
07-18 362
multiprocess模块 一. Process模块介绍 　　1. 直接使用Process模块创建进程 　　　　(1)主进程和子进程 　　　　(2)if __name__ == "__main__"语句 　　2. Process模块参数介绍 　　　　函数传参的两种方式 　　3. Process模块方法介绍 　　　　(1)join方法的使用 　　　　(2)for循环开启多个进程 　　4. Process模块属性介绍 　　5. 在windows中必须把Process()放到if __name__ == "__
对Python的多进程锁的使用方法详解
09-19
### Python多进程锁的使用方法详解 在进行多线程或多进程编程时，为了确保数据的一致性和安全性，通常需要引入锁机制。Python中的`multiprocessing`模块提供了创建和管理进程的功能，同时也包括了用于同步进程间...
Python多进程详解
ifhuke的博客
03-10 6282
Python多进程的详细教程
Python中的多进程与多线程详解
最新发布
qq_42591591的博客
09-29 803
【代码】Python中的多进程与多线程详解。
python多进程
Mr.Yan的专栏
04-14 1057
要让Python程序实现多进程（multiprocessing），我们先了解操作系统的相关知识。 Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。 子进程永远返回0，而父进程返回子进程的ID。
Python多进程代码示例
热门推荐
Ghjkku的博客
07-08 13万+
Python多进程代码示例
(python)多进程
marst437730201的博客
08-23 4066
工作中遇到任务较重且耗时相对较长的情况,这时候想起来用多进程处理这类IO 密集型任务.最重要的是,multiprocessing.Pool实在是简单又高效,充分利用了多核CPU同时并行处理多个任务.支持多进程并行处理，可以利用多核 CPU 提高任务的执行效率和速度。提供了简单易用的 API，方便进行任务的分发和结果的收集，代码编写相对简单。可以在一定程度上降低代码复杂度，例如避免手动创建和管理多个进程等。缺点：进程切换开销较大，特别是当进程池中进程数量过多时，容易产生性能瓶颈。
python logging日志模块以及多进程日志详解
12-24
更主要是 讨论在多进程环境下如何使用logging 来输出日志， 如何安全地切分日志文件。 1. logging日志模块介绍 python的logging模块提供了灵活的标准模块，使得任何Python程序都可以使用这个第三方模块来实现日志...
python 多进程共享全局变量之Manager()详解
09-18
在Python中，由于全局解释器锁（GIL）的存在，多线程并不能真正利用多核CPU进行并行处理，因此多进程成为了实现并行计算的有效方式之一。然而，在多进程环境下，进程之间的全局变量是无法共享的，因为每个进程都有...
Python多进程并发(multiprocessing)用法实例详解
09-21
### Python多进程并发(multiprocessing)用法实例详解 在Python编程中，为了提高程序运行效率及充分利用多核处理器资源，通常会选择使用多进程技术。Python标准库中的`multiprocessing`模块提供了丰富的功能来实现这...
Python多进程示例multiprocess.py
11-15
Python多进程示例multiprocess.py python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在 python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing， 只需要定义一个函数，Python会完成其他所有事情。借助这个包，可以轻松完成从单进程到 并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步， 提供了Process、Queue、Pipe、Lock等组件。
python多线程与多进程及其区别详解
01-01
本文通过一些具体的例子简单介绍一下python的多线程和多进程，后续会写一些进程通信和线程通信的一些文章。 python多线程 python中提供两个标准库thread和threading用于对线程的支持，python3中已放弃对前者的支持...
Python 中的多进程
a883774913的博客
06-20 1452
本文简要而简洁地介绍了Python编程语言中的多进程。 什么是多进程？为什么选择多进程？python中的多进程是如何实现的，以及模拟多进程运行方式的方法
python（21）实现多进程（1）
weixin_33984032的博客
08-11 145
参考链接：http://www.cnblogs.com/kaituorensheng/p/4445418.html python多进程：multiprocessing python中的多线程其实并不是真正的多线程，如果想要充分使用多核cpu的资源，在python中大部分情况下还是多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其...
python多进程编程
Cody的笔记本
09-02 7177
部分转载自：http://www.ibm.com/developerworks/cn/aix/library/au-multiprocessing/  Python 实现线程式编程非常简单，但是这种方法的一个缺陷就是它并不总是能够提高应用程序的速度，因为全局解释器锁（Glo
Python 多进程：multiprocessing、aiomultiprocess(异步多进程)
freeking101的博客
09-12 1万+
multiprocessing 包提供了本地和远程并发操作，通过使用子进程而非线程有效地绕过了全局解释器锁。 因此，multiprocessing 模块允许程序员充分利用给定机器上的多个处理器。
Python_多进程
weixin_33973600的博客
11-25 103
Python 多进程库 multiprocessing ,支持子进程、通信、数据共享、执行不同形式的同步 多进程，绕过gil ,实现多核的利用，多进程也是原生进程，由操作系统维护 在pycharm中，可能没有办法正常使用multiprocessing.Process，最好是在Linux中运行 Process 用于创建进程模块 Pool 用于创建管理进程池 ...
Python中多进程spawn模式下使用进程锁，需要做什么特殊处理
09-27
在Python中，当使用`multiprocessing`模块的`Process`类以及`spawn`启动模式创建子进程时，由于每个进程都是独立运行的，并不会共享全局变量或者直接访问其他进程的内存空间，因此一般不需要像在`fork`或`share`模式下那样去手动管理进程间通信或同步。但是，如果你确实需要在多个子进程中控制某些资源，比如数据库连接或文件操作，可以考虑以下几个步骤： 1. **进程局部锁**（如`Lock`、`RLock` 或 `Semaphore`）：使用`multiprocessing`提供的锁对象来保护对共享资源的访问。每个进程获取到锁之后才能进行相关的操作，完成后释放锁让其他等待的进程有机会。 ```python from multiprocessing import Lock lock = Lock() def process_function(): with lock: # 这里是对共享资源的操作 ``` 2. **队列或管道**：你可以通过`Queue`、`Pipe`或`Manager`类创建进程间通信机制，这样在子进程中通过传递消息的方式来协调对资源的访问。 ```python from multiprocessing import Queue queue = Queue() def process_function(queue): data = queue.get() # 获取数据，然后处理... # 处理完后发送信号或更新数据回队列 queue.put(result) ``` 3. **避免使用全局状态**：如果可能的话，尽量避免在`spawn`模式下使用全局变量，因为它们在子进程中是不可见的。 总之，在`spawn`模式下，虽然不需要共享内存，但确保资源安全的方式通常依赖于进程间通信和适当的同步机制。记住，`spawn`模式的主要优点是更快的启动时间和更好的安全性，因为它并不复制整个进程堆栈。所以，在设计时要考虑这种特性的影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值