Python-- concurrent包（异步并行任务编程模块）

最新推荐文章于 2024-05-15 20:03:31 发布
最新推荐文章于 2024-05-15 20:03:31 发布
阅读量534 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/python_lqx/article/details/91447680
版权

concurrent包

concurrent.futures

3.2版本引入的模块

  • 异步并行任务编程模块，提供一个高级的异步可执行的便利接口
  • 提供了2个池执行器
    ThreadPoolExecutor 异步调用的线程池的Executor
    ProcessPoolExecutor 异步调用的进程池的Executor

ThreadPoolExecutor对象

首先需要定义一个池的执行器对象，Executor类子类对象

方法含义
ThreadPoolExecutor(max_workers=1)池中至多创建max_workers个线程的池来同时异步执行，返回 Executor实例
submit(fn, *args, **kwargs)提交执行的函数及其参数，返回Future类的实例
shutdown(wait=True清理池

Future类

方法含义
done()如果调用被成功的取消或者执行完成，返回True
cancelled()如果调用被成功的取消，返回True
running()如果正在运行且不能被取消，返回True
cancel()尝试取消调用。如果已经执行且不能取消返回False，否则返回True
result(timeout=None)取返回的结果，timeout为None，一直等待返回；timeout设置到期，抛出concurrent.futures.TimeoutError 异常
exception(timeout=None)取返回的异常，timeout为None，一直等待返回；timeout设置到期，抛出concurrent.futures.TimeoutError 异常

ThreadPoolExecutor例子

import threading
from concurrent import futures
import logging
import time

# 输出格式定义
FORMAT = '%(asctime)-15s\t [%(processName)s:%(threadName)s, ' \
         '%(process)d:%(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)

def worker(n):
    logging.info('begin to work-{}'.format(n))
    time.sleep(5)
    logging.info('finished {}'.format(n))

# 创建线程池，池容量为3
executer = futures.ThreadPoolExecutor(max_workers=3)
fs = []
for i in range(3):
    future = executer.submit(worker, i)
    fs.append(future)

for i in range(3, 6):
    future = executer.submit(worker, i)
    fs.append(future)

while True:
    time.sleep(2)
    logging.info(threading.enumerate())

    flag = True
    for f in fs: # 判断是否还有未完成的任务
        logging.info(f.done())
        flag = flag and f.done()
        # if not flag: # 注释了这个if，方便观看输出的日志
        #     break

    print('-' * 30)
    if flag:
        executer.shutdown()
        logging.info(threading.enumerate())
        break

线程池一旦创建了线程，就不需要频繁清除

  • 执行结果
2019-06-11 16:10:53,824	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] begin to work-0
2019-06-11 16:10:53,824	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] begin to work-1
2019-06-11 16:10:53,826	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] begin to work-2
2019-06-11 16:10:55,828	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:10:55,828	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,828	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:55,829	 [MainProcess:MainThread, 341824:  339368] False
------------------------------
------------------------------
2019-06-11 16:10:57,829	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:10:57,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,829	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:57,830	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:58,825	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] finished 0
2019-06-11 16:10:58,825	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] begin to work-3
2019-06-11 16:10:58,826	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] finished 1
2019-06-11 16:10:58,826	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] begin to work-4
2019-06-11 16:10:58,827	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] finished 2
2019-06-11 16:10:58,827	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] begin to work-5
2019-06-11 16:10:59,830	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:10:59,830	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:10:59,831	 [MainProcess:MainThread, 341824:  339368] False
------------------------------
------------------------------
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:11:01,832	 [MainProcess:MainThread, 341824:  339368] False
2019-06-11 16:11:03,826	 [MainProcess:ThreadPoolExecutor-0_0, 341824:  341040] finished 3
2019-06-11 16:11:03,827	 [MainProcess:ThreadPoolExecutor-0_1, 341824:  341248] finished 4
2019-06-11 16:11:03,827	 [MainProcess:ThreadPoolExecutor-0_2, 341824:  335160] finished 5
------------------------------
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>, <Thread(ThreadPoolExecutor-0_0, started daemon 341040)>, <Thread(ThreadPoolExecutor-0_1, started daemon 341248)>, <Thread(ThreadPoolExecutor-0_2, started daemon 335160)>]
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,832	 [MainProcess:MainThread, 341824:  339368] True
2019-06-11 16:11:03,833	 [MainProcess:MainThread, 341824:  339368] [<_MainThread(MainThread, started 339368)>]

Process finished with exit code 0

ProcessPoolExecutor对象

  • 方法一样，就是使用多进程完成

ProcessPoolExecutor例子

import threading
from concurrent import futures
import logging
import time

# 输出格式定义
FORMAT = '%(asctime)-15s\t [%(processName)s:%(threadName)s, ' \
         '%(process)d:%(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)

def worker(n):
    logging.info('begin to work-{}'.format(n))
    time.sleep(5)
    logging.info('finished {}'.format(n))

if __name__ == '__main__':
    # 创建进程池，池容量为3
    executer = futures.ProcessPoolExecutor(max_workers=3)
    fs = []
    for i in range(3):
        future = executer.submit(worker, i)
        fs.append(future)

    for i in range(3, 6):
        futuer = executer.submit(worker, i)
        fs.append(future)

    while True:
        time.sleep(2)
        logging.info(threading.enumerate())

        flag = True
        for f in fs: # 判断是否还有未完成的任务
            logging.info(f.done())
            flag = flag and f.done()
            # if not flag: # 注释了这个if，方便观看输出的日志
            #     break

        print('-' * 30)

        if flag:
            executer.shutdown() # 清理池。除非不用了，否则不要频繁清理池
            logging.info(threading.enumerate()) # 多进程时看主线程已经没有必要了
            break
  • 执行结果
2019-06-11 16:22:34,441	 [Process-2:MainThread, 343300:  343320] begin to work-0
2019-06-11 16:22:34,466	 [Process-1:MainThread, 343260:  343312] begin to work-1
2019-06-11 16:22:34,488	 [Process-3:MainThread, 343232:  343328] begin to work-2
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>, <Thread(Thread-1, started daemon 343284)>, <Thread(QueueFeederThread, started daemon 343168)>]
------------------------------
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:36,201	 [MainProcess:MainThread, 343224:  343220] False
------------------------------
2019-06-11 16:22:38,201	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>, <Thread(Thread-1, started daemon 343284)>, <Thread(QueueFeederThread, started daemon 343168)>]
2019-06-11 16:22:38,201	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:38,202	 [MainProcess:MainThread, 343224:  343220] False
2019-06-11 16:22:39,442	 [Process-2:MainThread, 343300:  343320] finished 0
2019-06-11 16:22:39,442	 [Process-2:MainThread, 343300:  343320] begin to work-3
2019-06-11 16:22:39,467	 [Process-1:MainThread, 343260:  343312] finished 1
2019-06-11 16:22:39,467	 [Process-1:MainThread, 343260:  343312] begin to work-4
2019-06-11 16:22:39,488	 [Process-3:MainThread, 343232:  343328] finished 2
2019-06-11 16:22:39,488	 [Process-3:MainThread, 343232:  343328] begin to work-5
------------------------------
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>, <Thread(Thread-1, started daemon 343284)>, <Thread(QueueFeederThread, started daemon 343168)>]
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:40,202	 [MainProcess:MainThread, 343224:  343220] True
2019-06-11 16:22:44,442	 [Process-2:MainThread, 343300:  343320] finished 3
2019-06-11 16:22:44,468	 [Process-1:MainThread, 343260:  343312] finished 4
2019-06-11 16:22:44,488	 [Process-3:MainThread, 343232:  343328] finished 5
2019-06-11 16:22:44,511	 [MainProcess:MainThread, 343224:  343220] [<_MainThread(MainThread, started 343220)>]

Process finished with exit code 0

支持上下文管理

  • concurrent.futures.ProcessPoolExecutor继承自concurrent.futures._base.Executor，而父类有__enter__ 、__exit__方法，支持上下文管理。可以使用with语句
  • __exit__方法本质还是调用的shutdown(wait=True)，就是一直阻塞到所有运行的任务完成

使用方法

with ThreadPoolExecutor(max_workers=1) as executor:
	future = executor.submit(pow, 323, 1235)
	print(future.result())
  • 使用上下文改造上面的例子，增加返回计算的结果

ProcessPoolExecutor 上下文例子

import threading
from concurrent import futures
import logging
import time

# 输出格式定义
FORMAT = '%(asctime)-15s\t [%(processName)s:%(threadName)s, ' \
         '%(process)d:%(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)

def worker(n):
    logging.info('begin to work-{}'.format(n))
    time.sleep(5)
    logging.info('finished {}'.format(n))

if __name__ == '__main__':
    # 创建进程池，池容量为3
    executer = futures.ProcessPoolExecutor(max_workers=3)

    with executer: # 上下文管理
        fs = []
        for i in range(3):
            future = executer.submit(worker, i)
            fs.append(future)

        for i in range(3, 6):
            futuer = executer.submit(worker, i)
            fs.append(future)

        while True:
            time.sleep(2)
            logging.info(threading.enumerate())

            flag = True
            for f in fs: # 判断是否还有未完成的任务
                logging.info(f.done())
                flag = flag and f.done()
                # if not flag: # 注释了这个if，方便观看输出的日志
                #     break

            print('-' * 30)

            if flag:
                break
        # executer.shutdown() # 上下文清理了资源
    logging.info('===end===')
    logging.info(threading.enumerate()) # 多进程时看主线程已经没有必要了
  • 执行结果
2019-06-11 16:48:06,023	 [Process-2:MainThread, 344928:  346108] begin to work-0
2019-06-11 16:48:06,040	 [Process-1:MainThread, 342556:  343704] begin to work-1
2019-06-11 16:48:06,044	 [Process-3:MainThread, 334452:  344428] begin to work-2
2019-06-11 16:48:07,761	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>, <Thread(Thread-1, started daemon 342024)>, <Thread(QueueFeederThread, started daemon 343912)>]
2019-06-11 16:48:07,761	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:07,762	 [MainProcess:MainThread, 346100:  346096] False
------------------------------
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>, <Thread(Thread-1, started daemon 342024)>, <Thread(QueueFeederThread, started daemon 343912)>]
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,762	 [MainProcess:MainThread, 346100:  346096] False
2019-06-11 16:48:09,763	 [MainProcess:MainThread, 346100:  346096] False
------------------------------
2019-06-11 16:48:11,023	 [Process-2:MainThread, 344928:  346108] finished 0
2019-06-11 16:48:11,024	 [Process-2:MainThread, 344928:  346108] begin to work-3
2019-06-11 16:48:11,041	 [Process-1:MainThread, 342556:  343704] finished 1
2019-06-11 16:48:11,042	 [Process-1:MainThread, 342556:  343704] begin to work-4
2019-06-11 16:48:11,044	 [Process-3:MainThread, 334452:  344428] finished 2
2019-06-11 16:48:11,045	 [Process-3:MainThread, 334452:  344428] begin to work-5
------------------------------
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>, <Thread(Thread-1, started daemon 342024)>, <Thread(QueueFeederThread, started daemon 343912)>]
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:11,763	 [MainProcess:MainThread, 346100:  346096] True
2019-06-11 16:48:16,024	 [Process-2:MainThread, 344928:  346108] finished 3
2019-06-11 16:48:16,042	 [Process-1:MainThread, 342556:  343704] finished 4
2019-06-11 16:48:16,045	 [Process-3:MainThread, 334452:  344428] finished 5
2019-06-11 16:48:16,077	 [MainProcess:MainThread, 346100:  346096] ===end===
2019-06-11 16:48:16,077	 [MainProcess:MainThread, 346100:  346096] [<_MainThread(MainThread, started 346096)>]

Process finished with exit code 0

总结

  • 该库统一了线程池、进程池调用，简化了编程。
  • 是Python简单的思想哲学的体现。
  • 唯一的缺点：无法设置线程名称。但这都不值一提。
鹿夏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python3的concurrent包
haihaihai2232的博客
06-11 3256
concurrent包 concurrent.futures 3.2版本引入的模块. 异步并行任务编程模块, 提供一个高级的一部可执行的便利接口. 提供两个池执行器 ThreadPoolExecutor 异步调用的线程池的Executor ProcessPlloExecutor异步调用进程池的Executor 这两个池是惰性的, 不会立即创建线/进程 ThreadPoolExecutor对象 首先...
python concurrent.futures 实现并行计算
weixin_30297281的博客
12-11 125
python因为其全局解释器锁GIL而无法通过线程实现真正的并行计算。这个论断我们不展开，但是有个概念我们要说明，IO密集型 vs. 计算密集型。 IO密集型：读取文件，读取网络套接字频繁。 计算密集型：大量消耗CPU的数学与逻辑运算，也就是我们这里说的并行计算。 而concurrent.futures模块，可以利用multiprocessing实现真正的并行计算。 核心原理是：concu...
Python使用asyncio包实现异步编程
最新发布
读万卷书 行万里路
05-15 802
在Python中实现异步函数的定义需要两个关键字(async和awaitasyncasync关键字声明一个异步函数。它可以在执行过程中暂停并允许其他代码执行。当你调用一个异步函数时，它会立即返回一个协程对象而不是实际的结果。
Python：concurrent异步并行任务编程模块、 线程池、进程池、上下文管理
二十四桥明月夜
06-27 323
目录 concurrent包 ThreadPoolExecutor对象 ProcessPoolExecutor对象 支持上线文管理 总结 concurrent包 3.2版本引入的模块。 异步并行任务编程模块，提供一个高级的异步可执行的便利接口。 提供2个池执行器：ThreadPoolExcentor 异步调用线程池的Executor ProcessPoolExecutor 异步调用的进程池的Executor ThreadPoolExecutor对象 首先需要定义一个池的执行器对..
Python concurrent 包
weixin_44983653的博客
04-22 1165
Python concurrent 包1、`concurrent.futures`2、`ThreadPoolExecutor`3、`ProcessPoolExecutor`4、`ProcessPoolExecutor` 支持上下文管理 1、concurrent.futures 异步并行任务编程模块，提供一个高级的异步可执行的便利接口。 提供了两个池执行器： ThreadPoolExecutor 异步调用的线程池的Executor ProcessPoolExecutor 异步调用的进程池的Execut
Python标准模块_concurrent.futures
python学习者的博客
08-01 593
介绍： concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor：线程池，提供异步调用 ProcessPoolExecutor：进程池，提供异步调用 基本方法： submit(fn，*args,**kwargs) 异步提交任务 map（func，*iterables，timeout=NOne，chunksize=1）渠道for循环su...
ant-learn-python-concurrent-main.zip
05-24
python并发编程的一些资料
backport-util-concurrent（2.2 /3.1）
08-14
backport-util-concurrent（2.2 /3.1） 资源共享，有需要其他jar包的可以在评论留言，看到后我会陆续上传。
python-jsonrpc-server:Python 2和3异步JSON RPC服务器
05-26
使用Python 3的concurrent.futures模块和Python 支持异步请求处理。安装pip install -U python-jsonrpc-server 例子examples目录包含两个通过websocket运行语言服务器的示例。 examples/langserver.py显示了如何在...
Java-并发（Concurrent）编程
07-15
并发编程：编写多线程代码，解决多线程带来的问题 为什么要学并发编程？ 首先，来看一个案例：手写网站服务器案例。 高性能应用程序的一把钥匙，应用程序的翅膀，面试高频的考点 中间件几乎都是多线程应用：MySQL、...
Python资源之浏览器自动化与仿真-多进程并发-异步
08-28
4. concurrent.futures：是一个提供用于异步执行 callable 的高级接口，能够实现异步任务的执行。 异步编程技术： 异步编程是指使用异步方式来执行任务，以提高程序的执行效率。在 Python 中，常见的异步编程技术...
python并发技术实现（多线程、多进程）
12-07
压缩包内包含四个文件，实现的效果都是通过多线程或多进程执行加法运算； multiprocess_queue，通过任务队列方式实现多进程任务；(multiprocessing模块） multithread_queue，通过任务队列方式实现多线程任务；（threading模块） multiprocess_pool，通过进程池方式实现多进程任务；（concurrent.futures模块） multithread_pool，通过线程池方式实现多线程任务； （concurrent.futures模块）
python concurrent.futures 中文文档
04-15
python concurrent.futures最新官网文档中文翻译，自己手动翻译，请勿喷。。。。。
python并发模块之concurrent.futures(二)
dianyin7770的博客
06-21 76
python并发模块之concurrent.futures(二) 上次我们简单的了解下，模块的一些基本方法和用法，这里我们进一步对concurrent.futures做一个了解和拓展.上次的内容点这。python并发模块之concurrent.futures(二)以下载图片为例子，下面的程序是顺序下载http://www.58pic.com/newpic/28660111.html...
Python多线程模块concurrent.futures使用方法
什么都干的派森
12-04 926
1. python3.2之后可以使用concurrent.futures这个很方便的多线程模块，官网文档在这[https://docs.python.org/3.7/library/concurrent.futures.html#module-concurrent.futures](https://docs.python.org/3.7/library/concurrent.futures.html#module-concurrent.futures) 但文档写的不太通俗，于是总结了一个通用的案例，如下 3
python3线程池 多线程
qq_27886997的博客
09-27 1273
从Python3.2开始，标准库为我们提供了 concurrent.futures 模块，它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块，该模块通过 submit 返回的是一个 future 对象，它是一个未来可期的对象，通过它可以获悉线程的状态主线程(或进程)中可以获取某一个线程(进程)执行的状态或者某一个任务执行的状态及返回值： 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。 当一
python 2种线程池
Doub1's Blog
09-06 511
python 2种线程池threadpoll并发包concurrent.futures简单的栗子as_completedmapwait threadpoll import time import threadpool def sayhello(str): print "Hello ",str time.sleep(2) name_list =['aa','bb','cc','dd'] start_time = time.time() pool = threadpool.ThreadPo
32、python多进程编程代码演示
zhaopeng01zp的博客
10-27 348
print("Test Process") # 导入进程模块 from multiprocessing import Process import time, os # 创建进程 进程入口函数 进程参数（是个元组类型） def proc_func(name): print("proc_func") for j in range(10): # 打印进程号 print(j, "child func", name, os.getpid()) tim
PYTHON异步并发模块concurrent.futures
LY的博客
03-04 1590
1) python 3.x中自带了concurrent.futures模块2) python 2.7需要安装futures模块
Python并行编程手册
07-27
Python并行编程手册是一本介绍Python并行编程的指南。它包括了并行编程的定义、Python并行编程的优势以及Python多进程、多线程和异步编程的实现方式。此外，手册还提供了使用技巧，帮助读者优化Python并行编程效率。通过阅读这本手册，读者可以更深入地了解Python并行编程的实现方式和使用技巧，从而提高程序的运行效率和开发效率。\[1\] Python作为一款开放源代码语言，具有较完善的内置库，如multiprocessing库、concurrent.futures库、asyncio库等，这些库能够很好地支持并行编程。相对于其他语言，Python并行编程具有一些优势，如较完善的开发生态、丰富的第三方库选择、简洁易读的语法以及在多核场景下较好地利用CPU资源的GIL锁机制。\[2\] 当需要处理大量数据、进行复杂计算或高性能任务时，Python单线程的执行效率可能不够高。因此，使用并行编程技术可以加速程序运行，提高效率。\[3\] #### 引用[.reference_title] - *1* *2* *3* [chatgpt赋能python：Python并行编程手册](https://blog.csdn.net/boRRjxBZRf/article/details/131099342)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值