concurrent.futures的作用:
       管理并发任务池。concurrent.futures模块提供了使用工作线程或进程池运行任务的接口。线程和进程池API都是一样,所以应用只做最小的修改就可以在线程和进程之间地切换

1、基于线程池使用map()

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures
import threading
import time def task(n):
print('{}: 睡眠 {}'.format(threading.current_thread().name,n))
time.sleep(n / 10)
print('{}: 执行完成 {}'.format(threading.current_thread().name,n))
return n / 10 ex = futures.ThreadPoolExecutor(max_workers=2)
print('main: 开始运行')
results = ex.map(task, range(5, 0, -1)) #返回值是generator 生成器
print('main: 未处理的结果 {}'.format(results))
print('main: 等待真实结果')
real_results = list(results)
print('main: 最终结果: {}'.format(real_results))

futures_thread_pool_map.py

运行效果

[root@ mnt]# python3 futures_thread_pool_map.py
main: 开始运行
ThreadPoolExecutor-0_0: 睡眠
ThreadPoolExecutor-0_1: 睡眠
main: 未处理的结果 <generator object Executor.map.<locals>.result_iterator at 0x7f1c97484678>
main: 等待真实结果
ThreadPoolExecutor-0_1: 执行完成
ThreadPoolExecutor-0_1: 睡眠
ThreadPoolExecutor-0_0: 执行完成
ThreadPoolExecutor-0_0: 睡眠
ThreadPoolExecutor-0_0: 执行完成
ThreadPoolExecutor-0_0: 睡眠
ThreadPoolExecutor-0_1: 执行完成
ThreadPoolExecutor-0_0: 执行完成
main: 最终结果: [0.5, 0.4, 0.3, 0.2, 0.1]

 2、futures执行单个任务

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures
import threading
import time def task(n):
print('{}: 睡眠 {}'.format(threading.current_thread().name, n))
time.sleep(n / 10)
print('{}: 执行完成 {}'.format(threading.current_thread().name, n))
return n / 10 ex = futures.ThreadPoolExecutor(max_workers=2)
print('main :开始')
f = ex.submit(task, 5)
print('main: future: {}'.format(f))
print('等待运行结果')
results = f.result()
print('main: result:{}'.format(results))
print('main: future 之后的结果:{}'.format(f))

futures_thread_pool_submit.py

运行效果

[root@ mnt]# python3 futures_thread_pool_submit.py
main :开始
ThreadPoolExecutor-0_0: 睡眠 5
main: future: <Future at 0x7f40c0a6a400 state=running>
等待运行结果
ThreadPoolExecutor-0_0: 执行完成 5
main: result:0.5
main: future 之后的结果:<Future at 0x7f40c0a6a400 state=finished returned float>

3、futures.as_completed()按任意顺序运行结果

#!/usr/bin/env python
# -*- coding: utf-8 -*- import random
import time
from concurrent import futures def task(n):
time.sleep(random.random())
return (n, n / 10) ex = futures.ThreadPoolExecutor(max_workers=2)
print('main: 开始')
wait_for = [
ex.submit(task, i) for i in range(5, 0, -1)
]
for f in futures.as_completed(wait_for):
print('main: result:{}'.format(f.result()))

futures_as_completed.py

运行效果

[root@ mnt]# python3 futures_as_completed.py
main: 开始
main: result:(, 0.5)
main: result:(, 0.4)
main: result:(, 0.3)
main: result:(, 0.1)
main: result:(, 0.2)

4、Future回调之futures.add_done_callback()

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures
import time def task(n):
print('task {} : 睡眠'.format(n))
time.sleep(0.5)
print('task {} : 完成'.format(n))
return n / 10 def done(fn):
if fn.cancelled():
print('done {}:取消'.format(fn.arg))
elif fn.done():
error = fn.exception()
if error:
print('done {} : 错误返回 : {}'.format(fn.arg, error))
else:
result = fn.result()
print('done {} : 正常返回 : {}'.format(fn.arg, result)) if __name__ == '__main__':
ex = futures.ThreadPoolExecutor(max_workers=2)
print('main : 开始')
f = ex.submit(task, 5)
f.arg = 5
f.add_done_callback(done)
result = f.result()

futures_future_callback.py

运行效果

[root@ mnt]# python3 futures_future_callback.py
main : 开始
task : 睡眠
task : 完成
done : 正常返回 : 0.5

 5、Future任务取消之futures.cancel()

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures
import time def task(n):
print('task {} : 睡眠'.format(n))
time.sleep(0.5)
print('task {} : 完成'.format(n))
return n / 10 def done(fn):
if fn.cancelled():
print('done {}:取消'.format(fn.arg))
elif fn.done():
error = fn.exception()
if error:
print('done {} : 错误返回 : {}'.format(fn.arg, error))
else:
result = fn.result()
print('done {} : 正常返回 : {}'.format(fn.arg, result)) if __name__ == '__main__':
ex = futures.ThreadPoolExecutor(max_workers=2)
print('main : 开始')
tasks = [] for i in range(10, 0, -1):
print('main: submitting {}'.format(i))
f = ex.submit(task, i)
f.arg = i
f.add_done_callback(done)
tasks.append((i, f)) for i, task_obj in reversed(tasks):
if not task_obj.cancel():
print('main: 不能取消{}'.format(i)) ex.shutdown()

futures_future_callback_cancel.py

运行效果

[root@mnt]# python3 futures_future_callback_cancel.py
main : 开始
main: submitting
task : 睡眠
main: submitting
task : 睡眠
main: submitting
main: submitting
main: submitting
main: submitting
main: submitting
main: submitting
main: submitting
main: submitting
done :取消
done :取消
done :取消
done :取消
done :取消
done :取消
done :取消
done :取消
main: 不能取消9
main: 不能取消10
task : 完成
done : 正常返回 : 1.0
task : 完成
done : 正常返回 : 0.9

 6、Future异常的处理

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures def task(n):
print('{} : 开始'.format(n))
raise ValueError('这个值不太好 {}'.format(n)) ex = futures.ThreadPoolExecutor(max_workers=2)
print('main: 开始...') f = ex.submit(task, 5) error = f.exception()
print('main: error:{}'.format(error)) try:
result = f.result()
except ValueError as e:
print('访问结果值的异常 {}'.format(e))

futures_future_exception

运行效果

[root@mnt]# python3 futures_future_exception.py
main: 开始...
: 开始
main: error:这个值不太好
访问结果值的异常 这个值不太好

  7、Future上下文管理即利用with打开futures.ThreadPoolExecutor()

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures def task(n):
print(n) with futures.ThreadPoolExecutor(max_workers=2) as ex:
print('main: 开始')
ex.submit(task, 1)
ex.submit(task, 2)
ex.submit(task, 3)
ex.submit(task, 4)
print('main: 结束')

futures_context_manager.py

运行效果

[root@ mnt]# python3 futures_context_manager.py
main: 开始 main: 结束

 8、基于进程池使用map()

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures
import os def task(n):
return (n, os.getpid()) if __name__ == '__main__':
ex = futures.ProcessPoolExecutor(max_workers=2)
results = ex.map(task, range(50, 0, -1))
for n, pid in results:
print('task {} in 进程id {}'.format(n, pid))

futures_process_pool_map.py

运行效果

[root@ mnt]# python3 futures_process_pool_map.py
task in 进程id
task in 进程id
task in 进程id
task in 进程id
task in 进程id

9、基于进程池异常处理

#!/usr/bin/env python
# -*- coding: utf-8 -*- from concurrent import futures
import os
import signal def task(n):
return (n, os.getpid()) if __name__ == '__main__':
with futures.ProcessPoolExecutor(max_workers=2) as ex:
print('获取工作进程的id')
f1 = ex.submit(os.getpid)
pid1 = f1.result() print('结束进程 {}'.format(pid1))
os.kill(pid1, signal.SIGHUP) print('提交其它进程')
f2 = ex.submit(os.getpid)
try:
pid2 = f2.result()
except futures.process.BrokenProcessPool as e:
print('不能开始新的任务:{}'.format(e))

futures_process_pool_broken.py

运行效果

[root@ mnt]# python3 futures_process_pool_broken.py
获取工作进程的id
结束进程
提交其它进程
不能开始新的任务:A process in the process pool was terminated abruptly while the future was running or pending.

Python之concurrent.futures模块的使用的更多相关文章

  1. python之concurrent.futures模块

    一.concurrent.futures模块简介 concurrent.futures 模块提供了并发执行调用的高级接口 并发可以使用threads执行,使用ThreadPoolExecutor 或 ...

  2. Python之线程 3 - 信号量、事件、线程队列与concurrent.futures模块

    一 信号量 二 事件 三 条件Condition 四 定时器(了解) 五 线程队列 六 标准模块-concurrent.futures 基本方法 ThreadPoolExecutor的简单使用 Pro ...

  3. Python并发编程之线程池/进程池--concurrent.futures模块

    一.关于concurrent.futures模块 Python标准库为我们提供了threading和multiprocessing模块编写相应的多线程/多进程代码,但是当项目达到一定的规模,频繁创建/ ...

  4. 《转载》Python并发编程之线程池/进程池--concurrent.futures模块

    本文转载自Python并发编程之线程池/进程池--concurrent.futures模块 一.关于concurrent.futures模块 Python标准库为我们提供了threading和mult ...

  5. Python之路(第四十六篇)多种方法实现python线程池(threadpool模块\multiprocessing.dummy模块\concurrent.futures模块)

    一.线程池 很久(python2.6)之前python没有官方的线程池模块,只有第三方的threadpool模块, 之后再python2.6加入了multiprocessing.dummy 作为可以使 ...

  6. Python之网络编程之concurrent.futures模块

    需要注意一下不能无限的开进程,不能无限的开线程最常用的就是开进程池,开线程池.其中回调函数非常重要回调函数其实可以作为一种编程思想,谁好了谁就去掉 只要你用并发,就会有锁的问题,但是你不能一直去自己加 ...

  7. 45、concurrent.futures模块与协程

    concurrent.futures  —Launching parallel tasks    concurrent.futures模块同时提供了进程池和线程池,它是将来的使用趋势,同样我们之前学习 ...

  8. 线程池、进程池(concurrent.futures模块)和协程

    一.线程池 1.concurrent.futures模块 介绍 concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor:线程池,提供异步调用 Pro ...

  9. 35、concurrent.futures模块与协程

    concurrent.futures  —Launching parallel tasks    concurrent.futures模块同时提供了进程池和线程池,它是将来的使用趋势,同样我们之前学习 ...

随机推荐

  1. Number of Containers ZOJ - 3175(数论题)

    Problem Description For two integers m and k, k is said to be a container of m if k is divisible by  ...

  2. 大数据学习(2)- export、source(附带多个服务器一起启动服务器)

    linux环境中, A=1这种命名方式,变量作用域为当前线程 export命令出的变量作用域是当前进程及其子进程. 可以通过source 脚本,将脚本里面的变量放在当前进程中 附带自己写的tomcat ...

  3. C# 使用Emit实现动态AOP框架 进阶篇之优化

    目  录 C# 使用Emit实现动态AOP框架 (一) C# 使用Emit实现动态AOP框架 (二) C# 使用Emit实现动态AOP框架 (三) C# 使用Emit实现动态AOP框架 进阶篇之异常处 ...

  4. ubuntu14.04 x86编译upx 3.92 及so加固

    的参考文章: http://www.cnblogs.com/fishou/p/4202061.html 1.download upx和所依赖的组件 upx3.:https://www.pysol.or ...

  5. 简单了解soap协议

    SOAP的是什么的简写 soap是(Simple Object Access Protocal)的简写,即简单对象访问协议,它描述了一种在分散或分布式的环境中如何交换信息的轻量级协议. soap用来干 ...

  6. js之语句(表达式语句,复合语句,声明语句)

    语句就是JavaScript整句或命令,以分号结束,用来执行以使某件事发生.下面将介绍三种语句:表达式语句,复合语句,声明语句. 一.表达式语句 表达式语句是javascript中最简单的语句 < ...

  7. Spring AOP的理解和使用

    AOP是Spring框架面向切面的编程思想,AOP采用一种称为“横切”的技术,将涉及多业务流程的通用功能抽取并单独封装,形成独立的切面,在合适的时机将这些切面横向切入到业务流程指定的位置中. 掌握AO ...

  8. linux--mysql 8.0.16--裸机安装

    参考: https://www.cnblogs.com/warmsmile/p/10210739.html https://www.cnblogs.com/yg_zhang/p/10424926.ht ...

  9. ln建立时符号链接时出现同名文件或目录

    给ln命令加上-s选项,则建立软链接. 格式:ln -s [真正的文件或者目录] [链接名]   [链接名]可以是任何一个文件名或者目录名,并且允许它与原文件不在同一个文件系统中. 如果[链接名]是一 ...

  10. DA_05_Linux(CentOS6.7) 安装MySql5.7数据库

    1系统约定 安装文件下载目录:/data/software Mysql目录安装位置:/usr/local/mysql 数据库保存位置:/data/mysql 日志保存位置:/data/log/mysq ...