精华内容
下载资源
问答
  • 初始化 Pool 时,需要指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求,但是如果进程池中的进程已经达到指定的最大值,那么该请求 就会等待,直到池中有...

    当需要创建的子进程数量不多时,可以直接利用 multiprocessing 中的 Process 动态生成多个进程, 但是如果是上百甚至上千个目标,手动的去创建的进程的工作量巨大,此时就可以用到 multiprocessing 模块提供的 Pool 方法。也就是进程池。
    初始化 Pool 时,需要指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求,但是如果进程池中的进程已经达到指定的最大值,那么该请求 就会等待,直到池中有进程结束,才会用之前的进程来执行新的任务。
    进程池语法:
    from mutiprocessing import Pool
    po = Pool(num) #创建一个进程池
    po.apply_async() 使用进程池中的进程处理任务
    po.close() 关闭进程池,不再接受新的请求
    po.join() 令主进程等待子进程的执行
    代码实现:

    import multiprocessing
    import os
    import time
    
    def worker(msg):
        start_time = time.time()
        print(msg,f'开始运行,线程号{os.getpid()}')
        time.sleep(2)
        stop_time = time.time()
        print(msg, f'结束运行,所用时间{stop_time-start_time}')
    
    def main():
        #新建进程池
        pool = multiprocessing.Pool(3)
        for i in range(10):
            #开始执行任务
            pool.apply_async(worker,args=(i,))
        #关闭线程池,线程池不接接受新的任务
        #主进程阻塞,子进程不会结束
        print('主进程开始执行')
        pool.close()
        pool.join()
    if __name__ == '__main__':
        main()
    
    展开全文
  • Python多进程——进程池Pool

    千次阅读 2017-08-29 21:18:00
    1.初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果还没有满,那么就会创建一个新的进程用来执行该请求;但如果中的进程数已经达到指定的最大值,那么该请求就会等待,直到中有进程...
    1.初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来执行  

     2.multiprocessing.Pool常用函数解析:

    • apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表;异步,多个线程同时执行

    • apply(func[, args[, kwds]]):使用阻塞方式调用func,执行完一个进程后再去执行其他线程。

    • close():关闭Pool,使其不再接受新的任务;

    • terminate():不管任务是否完成,立即终止;

    • join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;

    • apply_async(func, args=(), kwds={}, callback=None, error_callback=None):callback:回调函数,可接收func函数的返回值

    3.注意点:

    • 主进程不会等待子进程结束后,再结束。需要加join()

    • join()必须放在close语句之后

    例:apply_async():异步

    from multiprocessing import Pool
    import os,time,random
    
    def worker(msg):
        t_start = time.time()
        print("%s开始执行,进程号为%d"%(msg,os.getpid()))
        #random.random()随机生成0~1之间的浮点数
        time.sleep(random.random()*2) 
        t_stop = time.time()
        print(msg,"执行完毕,耗时%0.2f"%(t_stop-t_start))
    
    po=Pool(3) #定义一个进程池,最大进程数3
    for i in range(0,10):
        #Pool.apply_async(要调用的目标,(传递给目标的参数元祖,))
        #每次循环将会用空闲出来的子进程去调用目标
        po.apply_async(worker,(i,))
    
    print("----start----")
    po.close() #关闭进程池,关闭后po不再接收新的请求
    po.join() #等待po中所有子进程执行完成,必须放在close语句之后
    print("-----end-----")

    结果:

    ----start----
    0开始执行,进程号为21466
    1开始执行,进程号为21468               #一次可执行3个进程,一个进程结束后,另一个进程接着使用该进程的资源。
    2开始执行,进程号为21467               #共3个pid:21466,21468,21467
    0 执行完毕,耗时1.01
    3开始执行,进程号为21466
    2 执行完毕,耗时1.24
    4开始执行,进程号为21467
    3 执行完毕,耗时0.56
    5开始执行,进程号为21466
    1 执行完毕,耗时1.68
    6开始执行,进程号为21468
    4 执行完毕,耗时0.67
    7开始执行,进程号为21467
    5 执行完毕,耗时0.83
    8开始执行,进程号为21466
    6 执行完毕,耗时0.75
    9开始执行,进程号为21468
    7 执行完毕,耗时1.03
    8 执行完毕,耗时1.05
    9 执行完毕,耗时1.69
    -----end-----

    例:apply()堵塞式

    from multiprocessing import Pool
    import os,time,random
    
    def worker(msg):
        t_start = time.time()
        print("%s开始执行,进程号为%d"%(msg,os.getpid()))
        #random.random()随机生成0~1之间的浮点数
        time.sleep(random.random()*2) 
        t_stop = time.time()
        print(msg,"执行完毕,耗时%0.2f"%(t_stop-t_start))
    
    po=Pool(3) #定义一个进程池,最大进程数3
    for i in range(0,10):
        po.apply(worker,(i,))
    
    print("----start----")
    po.close() #关闭进程池,关闭后po不再接收新的请求
    po.join() #等待po中所有子进程执行完成,必须放在close语句之后
    print("-----end-----")

    结果:

    0开始执行,进程号为21532
    0 执行完毕,耗时1.91
    1开始执行,进程号为21534
    1 执行完毕,耗时1.72
    2开始执行,进程号为21533           #共3个进程号
    2 执行完毕,耗时0.50              #一个程序执行完之后,在执行另一个
    3开始执行,进程号为21532
    3 执行完毕,耗时1.27
    4开始执行,进程号为21534
    4 执行完毕,耗时1.05
    5开始执行,进程号为21533
    5 执行完毕,耗时1.60
    6开始执行,进程号为21532
    6 执行完毕,耗时0.25
    7开始执行,进程号为21534
    7 执行完毕,耗时0.63
    8开始执行,进程号为21533
    8 执行完毕,耗时1.21
    9开始执行,进程号为21532
    9 执行完毕,耗时0.60
    ----start----
    -----end-----








    展开全文
  • Python进程池实现

    2020-04-29 15:30:17
    当需要创建的子进程数量不时,可以直接利用...初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果还没有满,那么就会创建一个新的进程用来执行该请求;但如果中的进程数已经达到指定的...

    当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。

    初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会用之前的进程来执行新的任务。

    进程池的使用:

    # -*- coding: UTF-8 -*-
    import multiprocessing
    import random,threading,time,string,os
    def test1(msg):
        t_start = time.time()
        print('%s开始执行,进程号为%d'%(msg,os.getpid()))
        time.sleep(random.random()*2)
        t_stop = time.time()
        print('%s执行完成,耗时%.2f'%(msg,t_stop-t_start))
    if __name__ == '__main__':
        po = multiprocessing.Pool(3)
        for i in range(10):
            # 每次循环将会用空闲出来的子进程去调用目标
            po.apply_async(test1,(i,))
        print('-------start--------')
        po.close()# 关闭进程池,关闭后po不再接收新的请求
        po.join()# 等待po中所有子进程执行完成,必须放在close语句之后
        print('--------end---------')

    输出结果:

    -------start--------
    0开始执行,进程号为72495
    1开始执行,进程号为72496
    2开始执行,进程号为72497
    1执行完成,耗时0.02
    3开始执行,进程号为72496
    0执行完成,耗时0.03
    4开始执行,进程号为72495
    4执行完成,耗时0.07
    5开始执行,进程号为72495
    2执行完成,耗时1.11
    6开始执行,进程号为72497
    5执行完成,耗时1.17
    7开始执行,进程号为72495
    3执行完成,耗时1.78
    8开始执行,进程号为72496
    7执行完成,耗时0.84
    9开始执行,进程号为72495
    6执行完成,耗时1.10
    9执行完成,耗时0.61
    8执行完成,耗时0.97
    --------end---------

    Process finished with exit code 0

    multiprocessing.Pool常用函数解析:

    1.apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行,阻塞方式必须等待上一个进程退出才能执行下一个进程)

    2.close():关闭Pool,使其不再接受新的任务;

    3.terminate():不管任务是否完成,立即终止;

    4.join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;

    附加:

    如果将apply_async换成apply,输出结果为:

    0开始执行,进程号为72521
    0执行完成,耗时0.97
    1开始执行,进程号为72522
    1执行完成,耗时0.23
    2开始执行,进程号为72523
    2执行完成,耗时0.68
    3开始执行,进程号为72521
    3执行完成,耗时0.19
    4开始执行,进程号为72522
    4执行完成,耗时0.16
    5开始执行,进程号为72523
    5执行完成,耗时0.86
    6开始执行,进程号为72521
    6执行完成,耗时0.01
    7开始执行,进程号为72522
    7执行完成,耗时1.50
    8开始执行,进程号为72523
    8执行完成,耗时1.62
    9开始执行,进程号为72521
    9执行完成,耗时1.09
    -------start--------
    --------end---------

    说明了apply处在传入一个进程后,会将程序阻塞,不仅子进程只能阻塞执行,连主进程也被阻塞。

    进程池中的Queue:使用multiprocessing.Manager()中的Queue(),而不是multiprocessing.Queue()

    下面的实例演示了进程池中的进程如何通信:

    # -*- coding: UTF-8 -*-
    import multiprocessing
    import random,threading,time,string,os
    def write(q):
        print('write启动(%s),父进程为(%s)'%(os.getpid(),os.getppid()))
        for i in 'python':
            q.put(i)
    def read(q):
        print('read启动(%s),父进程为(%s)'%(os.getpid(),os.getppid()))
        for i in range(q.qsize()):
            print('read从Queue获取到消息:%s'%q.get(True))
    if __name__ == '__main__':
    print("(%s) start" % os.getpid())
    q=multiprocessing.Manager().Queue()
    po=multiprocessing.Pool()
    po.apply_async(write,args=(q,))
    time.sleep(2)
    po.apply_async(read,args=(q,))
    po.close()
    po.join()
    print("(%s) end" % os.getpid())

    输出结果:

    (72502) start
    write启动(72504),父进程为(72502)
    read启动(72505),父进程为(72502)
    read从Queue获取到消息:p
    read从Queue获取到消息:y
    read从Queue获取到消息:t
    read从Queue获取到消息:h
    read从Queue获取到消息:o
    read从Queue获取到消息:n
    (72502) end

     

     

    展开全文
  • Python进程池

    千次阅读 2017-12-25 20:41:45
    进程池Pool 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...

    进程池Pool

    当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。

    初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会用之前的进程来执行新的任务,请看下面的实例:

    # -*- coding:utf-8 -*-
    from multiprocessing import Pool
    import os, time, random
    
    def worker(msg):
        t_start = time.time()
        print("%s开始执行,进程号为%d" % (msg,os.getpid()))
        # random.random()随机生成0~1之间的浮点数
        time.sleep(random.random()*2) 
        t_stop = time.time()
        print(msg,"执行完毕,耗时%0.2f" % (t_stop-t_start))
    
    po = Pool(3)  # 定义一个进程池,最大进程数3
    for i in range(0,10):
        # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
        # 每次循环将会用空闲出来的子进程去调用目标
        po.apply_async(worker,(i,))
    
    print("----start----")
    po.close()  # 关闭进程池,关闭后po不再接收新的请求
    po.join()  # 等待po中所有子进程执行完成,必须放在close语句之后
    print("-----end-----")
    

    运行结果:

    ----start----
    0开始执行,进程号为21466
    1开始执行,进程号为21468
    2开始执行,进程号为21467
    0 执行完毕,耗时1.01
    3开始执行,进程号为21466
    2 执行完毕,耗时1.24
    4开始执行,进程号为21467
    3 执行完毕,耗时0.56
    5开始执行,进程号为21466
    1 执行完毕,耗时1.68
    6开始执行,进程号为21468
    4 执行完毕,耗时0.67
    7开始执行,进程号为21467
    5 执行完毕,耗时0.83
    8开始执行,进程号为21466
    6 执行完毕,耗时0.75
    9开始执行,进程号为21468
    7 执行完毕,耗时1.03
    8 执行完毕,耗时1.05
    9 执行完毕,耗时1.69
    -----end-----
    

    multiprocessing.Pool常用函数解析:

    • apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表;
    • close():关闭Pool,使其不再接受新的任务;
    • terminate():不管任务是否完成,立即终止;
    • join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;

    进程池中的Queue

    如果要使用Pool创建进程,就需要使用multiprocessing.Manager()中的Queue(),而不是multiprocessing.Queue(),否则会得到一条如下的错误信息:

    RuntimeError: Queue objects should only be shared between processes through inheritance.

    下面的实例演示了进程池中的进程如何通信:

    
    # -*- coding:utf-8 -*-
    
    # 修改import中的Queue为Manager
    from multiprocessing import Manager,Pool
    import os,time,random
    
    def reader(q):
        print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in range(q.qsize()):
            print("reader从Queue获取到消息:%s" % q.get(True))
    
    def writer(q):
        print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in "itcast":
            q.put(i)
    
    if __name__=="__main__":
        print("(%s) start" % os.getpid())
        q = Manager().Queue()  # 使用Manager中的Queue
        po = Pool()
        po.apply_async(writer, (q,))
    
        time.sleep(1)  # 先让上面的任务向Queue存入数据,然后再让下面的任务开始从中取数据
    
        po.apply_async(reader, (q,))
        po.close()
        po.join()
        print("(%s) End" % os.getpid())
    

    运行结果:

    (11095) start
    writer启动(11097),父进程为(11095)
    reader启动(11098),父进程为(11095)
    reader从Queue获取到消息:i
    reader从Queue获取到消息:t
    reader从Queue获取到消息:c
    reader从Queue获取到消息:a
    reader从Queue获取到消息:s
    reader从Queue获取到消息:t
    (11095) End
    展开全文
  • python进程池

    2019-07-17 14:45:58
    python进程池 Python3 进程文档 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到...
  • python3 进程池Pool 详解

    千次阅读 2019-04-10 22:39:36
    进程池Pool 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。...
  • Python进程池

    2019-07-11 20:20:19
    Python进程池 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...
  • 进程池Pool 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...
  • Python多任务——进程池

    千次阅读 2019-02-24 15:39:32
    进程池Pool 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...
  • python进程池Pool

    2019-08-23 23:40:56
    进程池Pool 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...
  • python进程池pool

    2019-04-15 18:44:28
    进程池Pool 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...
  • python 进程池Pool

    2019-10-09 00:53:17
    进程池Pool 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...
  • 本文实例讲述了Python进程池Pool应用。分享给大家供大家参考,具体如下: 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程...
  • 进程池:用来创建个进程 当需要创建的⼦进程数量不时, 可以直接利⽤multiprocessing中的Process动态生成个进程, 但如果是上百甚⾄上千个⽬标, ⼿动的去创建进程的⼯作量巨⼤, 此时就可以⽤到...
  • 欢迎关注公众号:Python爬虫数据分析挖掘,回复【开源源码】免费获取更开源项目源码 公众号每日更新python知识和【免费...初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果还没有满,...
  • Python进程池Pool的使用

    2019-12-15 11:00:32
    1.进程池Pool 需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool...
  • 什么是进程池 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态生成个进程,如果是上百个甚至上千个目标,收订的去创建进程的工作量巨大,此时就可以用到multiprocess模块提供的Pool...
  • 初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果还没有满,name就会创建一个新的进程用来执行该请求,但如果中的进程数已经达到指定的最大值,name该请求就会等待,知道中有进程结束...
  • 当需要创建的子进程数量不时,可以直接利用...初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果还没有满,那么就会创建一个新的进程用来执行该请求;但如果中的进程数已经达到指定的...
  • Python中的进程池 进程池Pool 当需要创建的子进程数量不,可以直接利用multiprocessing中的Process动态的生成个进程。 但如果是上百个甚至上千个目标,手动的去创建线程工作量很大,此时就可以用到...
  • 当需要创建的子进程数量不时,可以直接...初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果还没有满,那么就会创建一个新的进程用来执行该请求;但如果中的进程数已经达到指定的最...
  • 故而,在此用python多进程实现一下文件夹的复制,这一功能用多线程自然也能实现。 功能实现 由于不知道要复制的文件夹里有多少文件,因此一个一个用multiprocessing.Process创建进程就不合适了。所以使用进程池...
  • 进程池 当需要创建的子进程数量不时,可以直接利用multiprocessing中的Process动态成生个进程,但如果是上百甚至上千个目标,手动的去创建过程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。 ...

空空如也

空空如也

1 2 3 4
收藏数 70
精华内容 28
关键字:

python多进程池初始化

python 订阅