Multiprocessing Pool.starmap_async() and Pool.starmap() in Python 实现并行、多输入任务

最新推荐文章于 2024-03-10 14:45:39 发布
最新推荐文章于 2024-03-10 14:45:39 发布
阅读量1.5k 收藏 2
点赞数 2
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40541102/article/details/130641350
版权

Python 实现并行、多输入任务

一、问题描述

  • 处理上万条数据
  • 数据处理任务有多个输入

二、解决办法

使用 Pool.starmap_async() 或 Pool.starmap() ，可以根据需求选择。

1. Pool.starmap_async() 和 Pool.starmap()的功能

  • 创建一个进程池，进程池中有多个进程，多个进程可以并行执行任务，以缩短任务处理时间。

2. Pool.starmap()与Pool.starmap_async()的区别

  • 相同点
    • starmap_async()和starmap()都可以用来发出带有多个参数调用进程池中的函数的任务。(Both the starmap_async() and starmap() may be used to issue tasks that call a function in the process pool with more than one argument.)
  • 区别
    • starmap_async()函数不会阻塞，而starmap()函数会阻塞。
    • starmap_async()函数返回AsyncResult，而starmap()函数返回目标函数返回值的可迭代对象
    • starmap_async()函数可以对返回值和错误执行回调函数，而starmap()函数不支持回调函数。

三、实例Pool.starmap()与Pool.starmap_async()在进程池中的使用方法

1. 定义任务处理函数

from random import random
from time import sleep
from multiprocessing.pool import Pool
import multiprocessing
import time, datetime
    
# task executed in a worker process
def task(x, y):
    t1 = str(datetime.datetime.now())[11:]
    z = x*y
    sleep(1)   # block for a moment
    t2 = str(datetime.datetime.now())[11:]
    # report a message
    identifier = multiprocessing.current_process().name
    print(f'Task {identifier}, start time: {t1}, end time: {t2}', flush=True)
    # return the generated value
    return z

2. Pool.starmap_async()定义和配置进程池，并行执行任务

# create and configure the process pool
with Pool() as pool:
    # prepare arguments
    items = [(i, random()) for i in range(10)]
    # issues tasks to process pool
    result = pool.starmap_async(task, items)
    # iterate results
    for result in result.get():
        print(f'Got result: {result}', flush=True)
# process pool is closed automatically

3. Pool.starmap()定义和配置进程池，并行执行任务

# create and configure the process pool
with Pool() as pool:
    # prepare arguments
    items = [(i, random()) for i in range(10)]
    # issues tasks to process pool
    result = pool.starmap_async(task, items)
    print(result)
# process pool is closed automatically

4. 测试，并分析结果

  • 串行 运行任务测试

    if __name__ == '__main__':
    t1 = time.time()
    items = [(i, random()) for i in range(10)]
    for item in items:
        z = task(item[0], item[1])
    t2 = time.time()
    print(f'Done. ({(1E3 * (t2 - t1)):.1f}ms) Process.')

    运行时间 time=10014.4 ms，结果如下：

    Task MainProcess, start time: 13:25:41.896662, end time: 13:25:42.897968
Task MainProcess, start time: 13:25:42.898297, end time: 13:25:43.899823
Task MainProcess, start time: 13:25:43.900057, end time: 13:25:44.900915
Task MainProcess, start time: 13:25:44.901269, end time: 13:25:45.902550
Task MainProcess, start time: 13:25:45.902764, end time: 13:25:46.904421
Task MainProcess, start time: 13:25:46.904628, end time: 13:25:47.905779
Task MainProcess, start time: 13:25:47.905974, end time: 13:25:48.906658
Task MainProcess, start time: 13:25:48.906912, end time: 13:25:49.908484
Task MainProcess, start time: 13:25:49.908724, end time: 13:25:50.910294
Task MainProcess, start time: 13:25:50.910528, end time: 13:25:51.910837
Done. (10014.4ms) Process.

  • 并行 运行任务测试

    • Pool.starmap_async() 设置 4个 进程并行

      # protect the entry point
if __name__ == '__main__':
    t1 = time.time()
    # create and configure the process pool
    with Pool(processes=4) as pool:
        # prepare arguments
        items = [(i, random()) for i in range(10)]
        # issues tasks to process pool
        result = pool.starmap_async(task, items)
        # iterate results
        for result in result.get():
            print(f'Got result: {result}', flush=True)      
    # process pool is closed automatically
    t2 = time.time()
    print(f'Done. ({(1E3 * (t2 - t1)):.1f}ms) Process.')

      运行时间 time=3027.1ms，结果如下：

      Task ForkPoolWorker-4, start time: 13:33:24.838418, end time: 13:33:25.839684
Task ForkPoolWorker-3, start time: 13:33:24.838547, end time: 13:33:25.839684
Task ForkPoolWorker-2, start time: 13:33:24.838292, end time: 13:33:25.839684
Task ForkPoolWorker-1, start time: 13:33:24.838231, end time: 13:33:25.839684
Task ForkPoolWorker-3, start time: 13:33:25.840190, end time: 13:33:26.841160
Task ForkPoolWorker-2, start time: 13:33:25.840530, end time: 13:33:26.841349
Task ForkPoolWorker-1, start time: 13:33:25.840703, end time: 13:33:26.841380
Task ForkPoolWorker-4, start time: 13:33:25.840296, end time: 13:33:26.841381
Task ForkPoolWorker-3, start time: 13:33:26.841865, end time: 13:33:27.842449
Task ForkPoolWorker-2, start time: 13:33:26.841977, end time: 13:33:27.843139
Got result: 0.0
Got result: 0.07020127371886742
Got result: 1.1256784597006964
Got result: 1.5461355349791022
Got result: 0.8560855815072403
Got result: 3.882912015620671
Got result: 1.7547963496144667
Got result: 1.0103926687967728
Got result: 4.760893202587357
Got result: 4.2627716915139695
Done. (3027.1ms) Process.

    • Pool.starmap() 设置 4个 进程并行

        # protect the entry point
  if __name__ == '__main__':
      t1 = time.time()
      # create and configure the process pool
      with Pool(processes=4) as pool:
          # prepare arguments
          items = [(i, random()) for i in range(10)]
          # issues tasks to process pool
          result = pool.starmap(task, items)
          print(result)  
      # process pool is closed automatically
  t2 = time.time()
  print(f'Done. ({(1E3 * (t2 - t1)):.1f}ms) Process.')

      运行时间 time=3026.7ms，结果如下：

      Task ForkPoolWorker-1, start time: 13:41:59.417044, end time: 13:42:00.418067
Task ForkPoolWorker-4, start time: 13:41:59.417248, end time: 13:42:00.418067
Task ForkPoolWorker-2, start time: 13:41:59.417206, end time: 13:42:00.418067
Task ForkPoolWorker-3, start time: 13:41:59.417213, end time: 13:42:00.418067
Task ForkPoolWorker-4, start time: 13:42:00.418833, end time: 13:42:01.419987
Task ForkPoolWorker-2, start time: 13:42:00.419155, end time: 13:42:01.420250
Task ForkPoolWorker-1, start time: 13:42:00.419356, end time: 13:42:01.420633
Task ForkPoolWorker-3, start time: 13:42:00.419487, end time: 13:42:01.420784
Task ForkPoolWorker-4, start time: 13:42:01.420545, end time: 13:42:02.421670
Task ForkPoolWorker-2, start time: 13:42:01.421409, end time: 13:42:02.422508
[0.0, 0.22916987317496185, 1.48514094188553, 2.6743708768075924, 1.5402186086037761, 4.265952360897589, 0.8526580381048074, 3.806662622060956, 0.8377934521648509, 6.092057694481896]
Done. (3026.7ms) Process.

  • 更多详细描述见 Multiprocessing Pool.starmap_async() in Python。

JLGao的博客
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
_multiprocessing_python多任务尝试_python_
09-30
关于运用python实现多任务，这是一个尝试，不一定做的有多好，请大家多提意见
解决windows下python3使用multiprocessing.Pool出现的问题
09-17
主要介绍了解决windows下python3使用multiprocessing.Pool出现的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Python中starmap有什么用的？
最新发布
m0_67847535的博客
03-10 1027
本文介绍了Python中的 starmap 函数，包括其作用、用法和实际应用场景。 starmap 函数是一个非常有用的工具，可以帮助简化代码、提高效率，在处理多个参数的情况下特别有用。希望本文能够帮助大家更好地理解和使用 starmap 函数，从而提高Python编程的效率和质量。
利用pycharm简单实现多进程
01-20
python多进程需要使用进程池 from multiprocessing.pool import Pool import time def worker(x): print(worker+{number}.format(number=x)) time.sleep(1) return starttime = time.time() GROUP_START = 1 GROUP_END = 20 if __name__ == '__main__': pool = Pool(4) group = ([x for x in range(GROUP_START, GR
python多线程与多进程的方法
辉的博客
02-14 1713
获取当前线程 import threading #返回当前线程 t=threading.current_thread() print(t) #获得这个线程的名字 t.getName() #判断线程是否存活 t.is_alive() 创建线程 import threading #创建一个线程 my_thread=threading.Thread() #创建一个名称为my_tread的线程 my_t...
python进程池map_python进程池pool的starmap的使用
weixin_39919089的博客
12-09 561
#!/usr/bin/env python3from functools import partialfrom itertools import repeatfrom multiprocessing import Pool, freeze_supportdef func(a, b):return a + bdef main():a_args = [1,2,3]second_arg = 1with ...
Python中的并行处理(Pool.map()、Pool.starmap()、Pool.apply()、)
热门推荐
Mogul的博客
09-22 2万+
1.并行处理 并行处理是一种在同一台计算机的多个处理器中同时运行任务的工作模式。这种工作模式的目的就是减少总的任务处理时间，但是进程之间的通信会有额外的开销，因此对小的任务而言，总的任务时间会有所增加而不是是减少。 在Python语言中，multiprocessing模块通过使用子进程（而不是线程）来运行独立的并行进程。它可以让您利用机器上的多个处理器（Windows和Unix），也就是说，多个进程可以完全独立的在内存中运行 2.自己的设备最多可以进行多少个并行处理 ......
[Python]进程间通讯与进程池
农家小舍
10-06 977
介绍了进程间通讯方式Pipe（一对一）和Queue（多对多），以及进程池相关概念
python进程池之创建子任务的函数总结
S_o_l_o_n的博客
06-25 1074
目录mapapplymap_async和apply_asyncimap和imap_unorderedstarmap和starmap_async python多进程标准库multiprocessing通过进程池启动多进程有以下几种方式，本文旨在说明这几种方式的区别：map、apply、map_async、apply_async、imap、imap_unordered、starmap、starmap_async。map函数签名：(func, iterable[, chunksize])
Python中的Process和Pool: 多进程处理的利器
涛哥聊Python
02-18 1093
Process类是模块中的一个核心类，用于创建一个单独的进程。每个Process对象都可以执行一个函数或者方法，从而在单独的进程中执行任务。Process和Pool，并通过示例代码演示了它们的基本用法。同时，也探讨了多进程在实际项目中的应用场景，包括并行计算、IO密集型任务和并行任务处理等。多进程处理是Python中一种强大的并行处理技术，可以提高程序的性能和效率，特别是在处理大规模数据或IO密集型任务时具有明显的优势。希望本文能够帮助大家更好地理解和运用多进程处理技术。
多进程爬天气质量数据.zip_multiprocessing_python天气数据_spider_spider python_天
09-23
a spider showing the method of multiprocessing in python
Python多进程库multiprocessing中进程池Pool类的使用详解
09-21
主要介绍了Python多进程库multiprocessing中进程池Pool类的使用详解,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python多进程multiprocessing.Pool类详解
09-20
主要为大家详细介绍了Python多进程multiprocessing.Pool类，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
python 多进程执行任务
aawuwuwuxx的博客
09-06 322
【代码】python 多进程执行任务。
python语法——使用Pool实现多进程并行
HappyRocking的专栏
11-08 1万+
简介 Pool 模块来自于 multiprocessing 模块。 multiprocessing 模块是跨平台版本的多进程模块，像线程一样管理进程，与 threading 很相似，对多核CPU的利用率会比 threading 好的多。 Pool 类可以提供指定数量的进程供用户调用，当有新的请求提交到Pool中时，如果池还没有满，就会创建一个新的进程来执行请求。如果池满，请求就会告知先等待，直到...
python starmap_用于多个参数的Python多处理pool.map
weixin_39868592的博客
12-22 1122
在Python多处理库中，是否有pool.map的变体支持多个参数？text = "test"def harvester(text, case):X = case[0]text+ str(X)if __name__ == '__main__':pool = multiprocessing.Pool(processes=6)case = RAW_DATASETpool.map(harvester(t...
【Python】学习多线程，多进程，多协程
lengyer的博客
08-20 294
Python多线程 参考 https://www.bilibili.com/video/BV1bK411A7tV?p=1 CPU密集型计算 CPU密集型（CPU—bound） CPU密集型也叫做计算密集型，是指I/O在很短的时间就可以完成，CPU需要大量的计算和处理，特点是CPU占用率高 例如：压缩解压缩、加密解密、正则表达式搜索 IO密集型计算 IO密集型指的是系统运作大部分的状况是CPU在等I/O（硬盘/内存）的读/写操作，CPU占用率低 例如：文件处理程序、网络爬虫程序、读写数据库程
python多线程线程池的map和starmap对比
Mocode的博客
08-06 785
map和starmap都是多线程中同步执行的方法，二者的差别在于用map函数放入线程池的任务只能接受一个参数；用starmap函数放入线程池的任务则可以接受多个参数。这样看来，starmap函数其实比map函数更好用。下面是案例分析（注意每个代码段里job函数的参数数量、使用的是map还是starmap）。
python pool.apply_async
06-10
`pool.apply_async()` 是 Python `multiprocessing` 模块中的一个方法，用于向进程池中提交异步任务。 其语法如下： ```python apply_async(func[, args[, kwds[, callback[, error_callback]]]]) ``` 其中，`func` 是要执行的任务函数，`args` 是要传入任务函数的参数，`kwds` 是要传入任务函数的关键字参数。`callback` 是任务执行完成后要调用的回调函数，`error_callback` 是任务执行发生错误时要调用的回调函数。 `apply_async()` 方法会立即返回一个 `AsyncResult` 对象，这个对象可以用来获取任务执行的结果或者等待任务执行完成。可以使用 `get()` 方法来获取任务的结果，或者使用 `wait()` 方法等待任务执行完成。 下面是一个使用 `pool.apply_async()` 方法的示例代码： ```python import multiprocessing def worker(num): """子进程要执行的任务""" result = num * 2 return result if __name__ == '__main__': # 创建进程池 pool = multiprocessing.Pool() # 提交任务到进程池中 results = [] for i in range(5): result = pool.apply_async(worker, args=(i,)) results.append(result) # 关闭进程池 pool.close() # 等待所有进程完成任务 pool.join() # 输出结果 for result in results: print(result.get()) ``` 在这个示例中，首先创建了一个进程池 `pool`，然后使用 `apply_async()` 方法向进程池提交任务，每个任务都会调用 `worker()` 函数，计算结果并返回。在提交完所有任务后，关闭进程池并等待所有进程完成任务。最后，遍历任务结果并输出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值