Python之多进程multiprocessing

最新推荐文章于 2024-05-25 02:30:00 发布
最新推荐文章于 2024-05-25 02:30:00 发布
阅读量966 收藏 2
点赞数 3
分类专栏： # Python三包 文章标签： multiprocessing 队列 进程

0 multiprocessing

multiprocessing是支持大量进程,类似于线程模块的API包.本包提供本地和远程并发,通过使用子进程而不是线程,可有效避免全局解释器锁的单步执行.因此,multiprocessing可充分利用机器上的多个处理器.
进程,是资源(CPU,内存)分配的基本单位,是运行程序的一个实例,程序运行时系统会创建一个进程,并分配资源,然后将进程放入进程就绪队列,进程调度器选中他的时候会为其分配CPU资源,程序真正开始运行.
Linux系统,在父进程中创建子进程,当进程接受到客户端的请求是,可以复制出一个子进程来处理,父进程仅监控请求,然后创建子进程去处理,实现并发.
CPU的核数,表示可以同时执行的进程数,解析一下,CPU可以处理成千上万个进程,但是,CPU每个核每个时刻只能处理一个任务即进程,所以,多任务并行是指同一时刻可以执行的进程数量.
线程,是程序运行的基本单位,是进程的一个执行流,是CPU调度和分配的基本单位,一个进程可由多个线程组成,线程间共享所有资源,每个线程有自己的堆栈和局部变量,线程有CPU独立调度执行,多CPU允许多个线程同时运行.

1 Pool

功能:进程池用于执行在pool类中提交的任务,即进程池用于控制发布任务的工作进程.支持超时和回调的异步结果,具有并行映射实现.进程池数量即为同时可执行的最大任务数量.

1.0 参数

Pool(process[,initializer[,initargs[,maxtasksperchild[,context]]]])

序号参数说明
1processes使用的工作进程数量,若为None,返回os.cpu_count()使用的cpu数量
2initializerinitializer不为None,每个工作进程启动时会调用initializer(*initargs)
3intiargs进程方法的参数
4maxtasksperchild该参数是工作进程在退出并替换为新的工作进程之前处理的最大进程数量,用于释放未使用的资源
5context指定启动工作进程的上下文

1.2 方法

序号方法描述
1close禁止任何任务进入进程池,当所有任务完成后工作进程退出
2terminate立即停止工作进程,不继续进行未完成的工作进程
3join等待工作进程退出,必须在close()或terminate()后使用,等待进程池中的所有子进程完成
4mapmap()内置函数的平行函数
5apply_async以非阻塞方式执行池中的任务,可同时执行开辟的池个数任务量
6apply以阻塞方式执行池中任务,即执行返回结果后,开放进程池,其他任务进入,继续执行

1.3 测试

1.3.1 Demo1

from multiprocessing import Pool
# 执行函数
def f(x):
    return x*x
if __name__ == "__main__":
	# 进程池数量:5
    with Pool(5) as p:
        print(p.map(f, [1, 3, 4]))

[1, 9, 16]

1.3.2 Demo2

进程池个数与任务个数相同.

  • pool_test.py
from multiprocessing import Pool
import os, time, random

def func_1():
    #os.getpid()获取当前的进程的ID
    print("\nRun task func_1, child process id: {}" .format(os.getpid())) 
    start = time.time()
    time.sleep(5) 
    end = time.time()
    print('Task fucn_1, runs {} seconds.'.format(end - start))

def func_2():
    print("\nRun task func_2, child process id: {}".format(os.getpid()))
    start = time.time()
    time.sleep(5)
    end=time.time()
    print('Task func_2 runs {} seconds.'.format(end - start))

def func_3():
    print("\nRun task func_3, child process id: {}".format(os.getpid()))
    start = time.time()
    time.sleep(5)
    end = time.time()
    print('Task func_3 runs {} seconds.'.format(end - start))

def func_4():
    print("\nRun task func_4, child process id: {}".format(os.getpid()))
    start = time.time()
    time.sleep(10)
    end = time.time()
    print('Task func_4 runs {} seconds.'.format(end - start))
        
if __name__=='__main__':
    function_list=  [func_1, func_2, func_3, func_4] 
    print("Parent process id: {}".format(os.getpid()))

    pool = Pool(4)
    for func in function_list:
        #Pool执行函数，apply执行函数,当有一个进程执行完毕后，会添加一个新的进程到pool中
        pool.apply_async(func)     

    print('Waiting for all subprocesses done...')
    # close()执行后不会有新的进程加入到pool
    pool.close()
    # join函数等待所有子进程结束
    pool.join()    
    print ('All subprocesses done.')
  • Result
Parent process id: 8592

Run task func_1, child process id: 9563
Run task func_3, child process id: 9565


Run task func_2, child process id: 9564
Run task func_4, child process id: 9566

Waiting for all subprocesses done...
Task func_3 runs 5.005031585693359 seconds.
Task fucn_1, runs 5.0050342082977295 seconds.
Task func_2 runs 5.003967046737671 seconds.
Task func_4 runs 10.02004051208496 seconds.
All subprocesses done.
  • Analysis
    (1) 进程池中进程最大数为4,即同时可运行4个程序或函数;
    (2) 将4个函数放入进程池,使用apply_async实现非阻塞,即可同时运行4个函数,从前三个的延迟时间都设为5可看出,基本同时输出结果;

1.3.3 Demo3

进程池进程数量小于任务个数.

  • pool_test.py
from multiprocessing import Pool
import os, time, random

def func_1():
    #os.getpid()获取当前的进程的ID
    print("\nRun task func_1, child process id: {}" .format(os.getpid())) 
    start = time.time()
    time.sleep(5) 
    end = time.time()
    print('Task fucn_1, runs {} seconds.'.format(end - start))

def func_2():
    print("\nRun task func_2, child process id: {}".format(os.getpid()))
    start = time.time()
    time.sleep(5)
    end=time.time()
    print('Task func_2 runs {} seconds.'.format(end - start))

def func_3():
    print("\nRun task func_3, child process id: {}".format(os.getpid()))
    start = time.time()
    time.sleep(5)
    end = time.time()
    print('Task func_3 runs {} seconds.'.format(end - start))

def func_4():
    print("\nRun task func_4, child process id: {}".format(os.getpid()))
    start = time.time()
    time.sleep(10)
    end = time.time()
    print('Task func_4 runs {} seconds.'.format(end - start))
        
if __name__=='__main__':
    function_list=  [func_1, func_2, func_3, func_4] 
    print("Parent process id: {}".format(os.getpid()))

    pool = Pool(2)
    for func in function_list:
        #Pool执行函数，apply执行函数,当有一个进程执行完毕后，会添加一个新的进程到pool中
        pool.apply_async(func)     

    print('Waiting for all subprocesses done...')
    # close()执行后不会有新的进程加入到pool
    pool.close()
    # join函数等待所有子进程结束
    pool.join()    
    print ('All subprocesses done.')
  • Result
Parent process id: 8592

Run task func_1, child process id: 10639
Run task func_2, child process id: 10640

Waiting for all subprocesses done...
Task fucn_1, runs 5.004624843597412 seconds.
Task func_2 runs 5.002416610717773 seconds.

Run task func_3, child process id: 10639
Run task func_4, child process id: 10640

Task func_3 runs 5.005084991455078 seconds.
Task func_4 runs 10.010075330734253 seconds.
All subprocesses done.
  • Analysis
    (1) 进程池进程数量为2,任务量为4,即同时执行2个任务,当执行完成一个任务之后,释放资源,并将另一个任务放入进程池;
    (2) close用于控制进程池的开关,即保证线程池内的任务顺利执行,而不被其他未加入进程池的任务打断;
    (3) join保证了进程池中任务的子进程正常进行,即进程池中的任务包含的子进程全部完成后,才最终退出,即上面结果中的时间输出,当所有时间输出后,进程任务结束;

2 Pipe

2.1 功能

返回一对表示管道末端的连接对象(conn1, conn2),进程间的管道内部机制通过启动socket连接来保持进程间的通讯.

2.2 参数

Pipe([duplex])
duplex为True(默认),pipe是双向的,若为False,pipe为单向的,conn1只能接受消息,conn2只能发送消息;

2.3 Demo

from multiprocessing import Process, Pipe
def server_process(con):
    # 向客户端进程发送数据
    con.send("xin")
    # 接受客户端进程数据
    print("From father process: {}".format(con.recv()))
    
if __name__ == "__main__":
    # 实例化管道Pipe,建立socket连接
    # 服务端和客户端,conn1,conn2
    server, client = Pipe()
    # 开始服务端进程
    p = Process(target=server_process, args=(server, ))
    p.start()
    # 客户端接受服务端进程数据
    client_process = client.recv()
    print("Received server data: {}".format(client_process))
    client.send("daqi")

Received server data: xin
From father process: daqi

3 Queue

3.1 功能

返回使用pipe和lock/semaphores实现的共享队列进程,用于进程间通信.先进先出(First Input First Output, FIFO);当一个进程将一个项目放入队列时,会启动一个feeder线程,该线程将对象从缓冲区传送到pipe中.

3.2 参数

Queue(maxsize=0)

参数描述
maxsize整数,设置可放入队列的项目数上限.数据填满队列后,进入阻塞,知道队列内容取出.若maxsize小于等于0,队列数目无限制.

3.3 方法

序号参数描述
1qsize()返回队列数量的近似值
2empty()若队列为空,返回True
3full()队列全部占满,返回True
4put(obj[,block[,timeout]])将obj放入队列,若block为True(默认),timeout=None(默认),队列中无空闲位置时会阻塞,若timeout为正数,阻塞时间最长为timeout秒,若仍无空闲位置,则会调用queue.Full
5get([block[,timeout]])从队列获取对象并移除该对象,若block为True(默认),timeout=None(默认),队列中无空闲位置时会阻塞,若timeout为正数,阻塞时间最长为timeout秒,若阻塞结束后仍不能去除对象,则会调用queue.Empty

3.4 Demo1

from multiprocessing import Queue, Process
# 数据进队列
def queue_test(que):
    que.put("xindaqi")
    
if __name__ == "__main__":
    # 建立队列,10个卡位
    Q = Queue(10)
    # 建立进程,将队列作为参数,传入队列操作函数
    p = Process(target=queue_test, args=(Q, ))
    p.start()
    p.join()
    print("Queue data: {}".format(Q.get()))

Queue data: xindaqi

3.5 Demo2

from multiprocessing import Queue, Pool
import time

def queue_test(q):
    # 数据入队列
    for i in range(2):
        q.put(i)
        # 取出队列数据
        q_output = q.get()
        print("Queue data: {}".format(q_output))
        
if __name__ == "__main__":
    Q = Queue(10)
    start_time = time.time()
    # 建立3个线程,同时执行3个任务
    pool = Pool(3, queue_test, (Q, ))
    pool.terminate()
    end_time = time.time()
    cost_time = end_time - start_time
    print("Cost time: {}".format(cost_time))

Queue data: 0
Queue data: 0
Queue data: 1
Queue data: 0
Queue data: 1
Queue data: 1
Cost time: 0.11123538017272949

4 Process

4.1 功能

表示在运行的独立进程,进程类拥有所有threading.Thread方法.

4.2 参数

Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

序号参数描述
1group设定为None,作用只是为了和threading.Thread兼容
2targetrun()方法调用的可执行对象,如函数
3name进程名称
4argstuple类型的参数
5kwargsdict类型的参数
6daemon进程标志为,若为None(默认为None),该标志从创建的进程中继承

4.3 方法

序号方法描述
1run()表示进程活动的方法
2start()开启进程
3join([timeout])默认timeout=None,结束前(terminate),进程是阻塞的,若timeout为正数,表示最大的阻塞时长(秒)
4name进程名称
5is_alive()返回进程是否活动
6daemon进程守护标志,在start()前使用
7pid返回进程ID,在start()之后,即启动进程后,才有ID,否则返回None
8terminate()结束进程
9kill()杀死进程,类似terminate,只能在Unix
10close()关闭进程,释放资源

4.4 Demo

from multiprocessing import Process
import os

def info(title):
    print("Title: {}".format(title))
    print("module name: {}".format(__name__))
    print("Parent process: {}".format(os.getppid()))
    print("Subprocess id: {}".format(os.getpid()))
def f(name):
    info("function f")
    print("Hello {}".format(name))
    
if __name__ == "__main__":
    info("Main line")
    print("==================")
    p = Process(target=f, args=('xindaqi',))
    p.start()
    p.join()

Title: Main line
module name: __main__
Parent process: 29719
Process id: 29755
==================
Title: function f
module name: __main__
Parent process: 29755
Process id: 17714
Hello xindaqi

[参考文献]
[1]https://docs.python.org/3/library/multiprocessing.html#multiprocessing.pool.Pool
[2]https://www.cnblogs.com/zhehan54/p/6130030.html
[3]http://www.cnblogs.com/wdliu/p/6828070.html
[4]https://www.cnblogs.com/kaituorensheng/p/4465768.html

天然玩家
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python pathos模块多进程池无法完全退出
qq_24296409的博客
06-11 1126
Python pathos multiprocessing 进程池导致主进程无法退出
python强制释放内存_我如何使用子进程强制python释放内存？
weixin_39903872的博客
12-03 485
user48151623..31优化建议的重要一点是确保my_function()只在子进程中调用.该deepcopy和del是无关的-一旦你创建的过程包含五个百万个不同整数,同时持有到所有的人,过来的游戏.即使你不再引用这些对象,Python也会通过在一个边界中保留对500万个空整数对象大小的字段的引用来释放它们,它们等待重用于下一个想要创建500万个整数的函数.这是另一个答案中提到的免费列表,...
Python使用multiprocessing实现多进程
最新发布
若不知道要驶向哪个码头，那么任何风都不会是顺风。
05-25 2774
大家好，当我们工作中涉及到处理大量数据、并行计算或并发任务时，Python的multiprocessing模块是一个强大而实用的工具。通过它，我们可以轻松地利用多核处理器的优势，将任务分配给多个进程并同时执行，从而提高程序的性能和效率。在本文中，我们将探索如何使用multiprocessing模块实现多进程编程。将介绍进程池的概念和用法，以及如何使用它来管理和调度多个进程。我们还将讨论并发任务的处理、进程间通信和结果获取等关键问题，希望能给大家的工作带来一些帮助。
python 多进程进程退不出问题
紫无之紫的博客
12-22 1540
python脚本进程退不出问题
Python 多进程池中子进程挂了导致进程不能结束的问题小结
mxdsdo09的博客
08-16 7699
问题：Python multiprocessing pool not shutting down while child processes is oom 开篇点题：在使用python的multiprocessing中的pool时，会出现子进程因为各种原因挂了之后主进程任务停不下来的情况。这是因为主进程没能发现子进程挂了而判定结束，从而卡在了这个地方，是python的一个bug。解决办法有两个，且看下文分解～
python processpoolexector 释放内存_Python多进程--进程完成时如何释放内存？
weixin_39713335的博客
11-23 496
我在使用python多处理库时遇到了一个奇怪的问题。下面是我的代码草图：我为每个“symbol, date”元组生成一个进程。后来我把结果结合起来。我希望当一个进程完成了“symbol, date”元组的计算时，它应该释放它的内存？在进程完成计算之后，我如何让它释放它的内存呢？我指的是他们在ps命令中的状态，显示为“S+”。def do_one_symbol( symbol, all_date_s...
Python多进程multiprocessing用法实例分析
09-21
Python的`multiprocessing`模块是实现多进程编程的关键工具，它允许我们利用多核处理器的并行计算能力，提高程序的执行效率。在Python中，线程（threading）主要用于处理I/O密集型任务，而多进程（multiprocessing）...
Python3多进程 multiprocessing 模块实例详解
09-20
Python3的`multiprocessing`模块是用于实现多进程编程的核心工具，它允许程序创建和管理多个并发执行的进程。在Python中，多进程是通过复制主进程并分配独立的内存空间来实现的，每个进程都有自己的全局变量和堆栈，...
简单学习Python多进程Multiprocessing
09-21
Python的多进程模块Multiprocessing是Python中用于实现并发执行任务的重要工具，特别是在处理CPU密集型任务时，能够充分利用多核处理器的优势。本文将详细介绍Multiprocessing的基本概念、如何创建进程、利用队列...
Python多进程multiprocessing、进程池用法实例分析
09-17
### 多进程multiprocessing **创建与运行进程** 1. **进程创建**：使用`multiprocessing.Process`类创建进程，传入`target`参数为要执行的函数名，`args`参数为函数的参数元组。例如： ```python from ...
Python多进程并发(multiprocessing)用法实例详解
09-21
### Python多进程并发(multiprocessing)用法实例详解 在Python编程中，为了提高程序运行效率及充分利用多核处理器资源，通常会选择使用多进程技术。Python标准库中的`multiprocessing`模块提供了丰富的功能来实现这...
Python多进程multiprocessing --- 基于进程的并行
TracelessLe的专栏
07-18 2398
前言 在Python中，multiprocessing 是一个用于产生进程的包，它具有与用于产生线程的包threading相似的API。 multiprocessing 包同时提供本地和远程并发，使用子进程代替线程，有效避免了Python中GIL锁????（ Global Interpreter Lock ）带来的影响。通过它能充分利用机器上的多核，加快处理速度。 注：最新内容移步官网查看，本文仅对个人使用过程中的一些体会作记录和注解。 multiprocessing核心模块 Process 类 在
python 超时退出程序_python – 如何在超时后中止multiprocessing.Pool中的任务？
weixin_39901571的博客
12-10 943
这是一种无需更改工作函数即可完成此操作的方法.我们的想法是将worker包装在另一个函数中,该函数将在后台线程中调用worker,然后等待超时秒的结果.如果超时到期,则会引发异常,这将突然终止正在执行的线程工作者：import multiprocessingfrom multiprocessing.dummy import Pool as ThreadPoolfrom functools impo...
Multiprocessing之Pool类的简单解读，看了就能使用
XIAOFEI@IDO
11-28 5847
Multiprocessing之Pool类解读 一、Pool类介绍 在之前的博客中有对并行和并发进行了介绍。在python种主要存在两种方法实行：多线程和多进程。 对于python来说，多线程实际上是并发的，并没有完全利用多核的优势。当然这也要看具体的需求，如果是计算密集型的，多采用并行的方法；如果是IO密集型的，多采用并发的方法。这要是考虑到互相切换的开销。 解下来，我们介绍一种多进程的方法：Pool类。Pool可以提供指定数量的进程，供用户调用。当有新的请求提交到Pool中时，如果Pool还没有满，此时
python multiprocessing Pool类 多进程执行多个有输入参数的函数
NLOS的博客
03-17 1903
在这个示例中，定义了两个具有多个参数的函数 function_1 和 function_2。这样，就可以使用 Pool 类处理具有多个参数的不同函数。
Python使用multiprocessing.Pool实现固定数量线程池
Bulut0907
01-08 4443
目录1. Python使用multiprocessing.Pool实现固定数量线程池 1. Python使用multiprocessing.Pool实现固定数量线程池 from multiprocessing import Pool, cpu_count import time import os def thread_task(number): print("线程id为: %d, 处理的任务为：%d, 线程处理【开始】" % (os.getpid(), number)) time.s
【python】多进程multiprocessing模块、进程池的使用
magic_ll的博客
07-09 2436
python的多进程、进程池的使用
python的multiprocessing模块进程创建、资源回收-Process
zkpython的博客
06-18 633
import multiprocessing as ms def test(): pass p1 = ms.Process(target=test) # 创建子进程 p1.start() # 子进程 开始执行 p1.join() # 等待子进程结束 特点： 1.注意：Process对象可以创建进程，但Process对象不是进程，其删除与否与系统资源是否被回收没有直接的关系。 2.主进程执行完毕后会默认等待子进程结束后回收资源，不需要手动回收资源；join()函数用来控制子进程 结束的顺序,其内.
【Python】Python进程池multiprocessing.Pool八个函数对比：apply、apply_async、map、map_async、imap、starmap...
热门推荐
随波一落叶
10-24 1万+
map 和 map_async 可以并发执行任务。apply 和 apply_async 一次只能执行一个任务，但 apply_async 可以异步执行，因而也可以实现并发。 一、单次执行 1、单次同步执行 一个任务执行完再进行下一个任务 import multiprocessing import time def func(msg): print("msg:", msg) time.sleep(2) print("end") if __name__ == "__m
python多进程multiprocessing
06-28
### 回答1： Python多进程（multiprocessing）是一种并行计算的方式，可以在多个CPU核心上同时执行任务，提高程序的运行效率。它可以通过创建多个进程来实现并行计算，每个进程都有自己的独立内存空间，可以独立运行。在Python中，可以使用multiprocessing模块来实现多进程编程，它提供了一系列的类和函数，可以方便地创建和管理多个进程。使用multiprocessing模块可以有效地提高程序的运行速度，特别是在处理大量数据或计算密集型任务时，效果更加明显。 ### 回答2： Python多进程multiprocessing是一个用来创建并行程序的模块，它允许Python程序同时运行多个进程，从而大幅提高程序的运行效率。在Python中，多进程可以通过fork()系统调用实现，但是由于在Windows上无法完全实现fork()，因此Python在Windows上仅支持多线程，而不支持多进程。 Python多进程中最基本的概念是进程（Process）。在Python中，创建进程有两种基本的方式：使用Process类和使用Pool类。Process类允许我们创建一个进程对象，可以给进程传递参数并启动进程。Pool类则可以创建多个进程，并且自动分配任务到不同的进程中。 Python中还有一些重要的概念和技巧，例如进程间通信（IPC）、共享内存、信号量、锁等。进程间通信是在多进程应用程序中非常常见的技术，它可以让不同的进程之间进行数据交换、资源共享等操作。共享内存则允许不同的进程访问同一个内存区域，从而避免了复制数据的过程，提高了程序的效率。 对于使用Python多进程multiprocessing进行开发的程序，我们需要借助Python标准库中的一些附加模块，例如queue、threading、signal等，以及一些第三方库，例如PyQt、numpy等。对于不同的应用场景，我们可以选择不同的库和技术，从而实现最佳的多进程方案。 总体而言，Python多进程multiprocessing是一个非常强大的模块，可以大幅提高Python程序的运行效率和并发性能。不过，要想熟练地运用这个模块，需要对Python的多线程、操作系统和计算机架构等知识有一定的了解。同时，对于更高级别的多进程应用，可能还需要一些专业的领域知识。 ### 回答3： Python是一种面向对象、解释型、高级编程语言，其简洁、易读、易学的语法特点赢得了大批开发者的青睐。而multiprocessing则是Python的一个重要模块，可用于实现多进程并发编程，充分利用计算机多核心资源，提高Python程序的运行效率。 multiprocessing模块的主要特点包括： 1. 提供了Process、Pool、Queue等多个类和函数，方便实现进程的创建、管理和通信。 2. 可以使用fork进程创建新的进程，并可在进程之间共享数据，也可以将任务分配给多个进程执行，提高效率。 3. 提供了多种进程间通信机制的实现，如Pipe、Queue、Value和Array等，让进程之间的通信更加方便，同时保证数据的正确和安全。 4. 灵活的参数设置和控制，比如可以设置进程数、超时时间等，让程序更加可控和稳定。 使用multiprocessing模块可以带来显著的性能提升，特别适合需要处理大规模数据、密集计算或者需要高并发的应用场景。例如，在爬取大规模网站数据时，可以把每个网站的数据抓取任务分配给不同的进程去执行，节约大量时间。在图像处理和机器学习方面也可以大大加快程序的速度。 总之，Python的multiprocessing模块为我们提供了一种易用、高效的多进程编程方法，使我们能够更好地利用计算机资源，提高Python程序的性能和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值