python3 - concurrent.futures模块 - 进程池&线程池

最新推荐文章于 2024-08-26 15:59:40 发布
最新推荐文章于 2024-08-26 15:59:40 发布
阅读量3.8k 收藏 17
点赞数 3
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33961117/article/details/82587873
版权

目录

一、概念总结

1-1 池：控制进程数或线程数的概念。

1-2 同步&异步调用：提交任务的两种方式

1-3 阻塞&非阻塞：程序的运行状态

二、concurrent.futures 模块实现‘池’

2-0 concurrent.futures基本总结

2-0-1 基本方法（进程池和线程池都适用）

2-1 进程池

2-1-1 进程池的两种任务提交方式

2-1-2 进程池的同步调用方式

2-1-3 进程池的异步调用方式

2-1-4 进程池,异步调用+回调函数：解决耦合，速度慢

2-2 线程池：异步+回调 ---- IO密集型主要使用方式

一、概念总结

1-1 池：控制进程数或线程数的概念。

服务器开启的进程数或线程数，会随并发的客户端数目单调递增。会产生巨大的压力于服务器，于是使用“池”的概念，对服务端开启的进程数或线程数加以控制

  • - 进程池：用来存放进程的‘池’
  • - 线程池：用来存放线程的‘池’

1-2 同步&异步调用：提交任务的两种方式

  • - 同步调用：提交任务，原地等待任务执行结束，拿到任务返回结果。再执行下一行代码，会导致任务串行执行。
  • - 异步调用：提交任务，不进行原地等待，直接执行下一行代码，任务并发执行。

1-3 阻塞&非阻塞：程序的运行状态

  • - 阻塞：程序遇到IO操作等，进行原地等待，即阻塞态
  • - 非阻塞：程序未遭遇IO操作等，不进行等待，即运行态、就绪态

二、concurrent.futures 模块实现‘池’

2-0 concurrent.futures基本总结

  • concurrent.futures模块提供了高度封装的异步调用接口
    • ThreadPoolExecutor：线程池，提供异步调用
    • ProcessPoolExecutor: 进程池，提供异步调用

2-0-1 基本方法（进程池和线程池都适用）

submit(fn, *args, **kwargs) # 异步提交任务
'''
！！！注意：submit提交后返回的结果是一个future对象，需要使用future对象.result才能获取想要的字符串等结果
'''

map(func, *iterables, timeout=None, chunksize=1)  # 取代for循环submit的操作

shutdown(wait=True) 
'''
相当于进程池的pool.close()+pool.join()操作
wait=True，等待池内所有任务执行完毕回收完资源后才继续
wait=False，立即返回，并不会等待池内的任务执行完毕
但不管wait参数为何值，整个程序都会等到所有任务执行完毕
submit和map必须在shutdown之前
'''

result(timeout=None) # 取得结果

add_done_callback(fn) # 回调函数

2-1 进程池

2-1-1 进程池的两种任务提交方式

方式一、同步调用方式

from concurrent.futures import ProcessPoolExecutor
import time, random, os

def task(name):
    print('%s %s is running' % (name, os.getpid()))
    time.sleep(random.randint(1, 3))

if __name__ == '__main__':
    p = ProcessPoolExecutor(4)  # 设置进程池内进程数
    for i in range(10):
        # 同步调用方式，调用和等值。
         obj = p.submit(task, '进程pid：')  # 传参方式 （任务名，参数），参数使用位置参数或者关键字参数
        res = obj.result()
    p.shutdown(wait=True)  # 关闭进程池的入口，等待池内任务运行结束
    print('主')

方式二、异步调用方式

from concurrent.futures import ProcessPoolExecutor
import time, random, os

def task(name):
    print('%s %s is running' % (name, os.getpid()))
    time.sleep(random.randint(1, 3))

if __name__ == '__main__':
    p = ProcessPoolExecutor(4)  # 设置进程池内进程数
    for i in range(10):
        # 异步调用方式，只调用，不等值
        p.submit(task, '进程pid：')  # 传参方式 （任务名，参数），参数使用位置参数或者关键字参数

    p.shutdown(wait=True)  # 关闭进程池的入口，等待池内任务运行结束
    print('主')

2-1-2 进程池的同步调用方式

'''
同步调用方式解析：
   缺点：解耦合
   优点：速度慢
'''
from concurrent.futures import ProcessPoolExecutor
import time, os
import requests


def get(url):
    print('%s GET %s' % (os.getpid(), url))
    time.sleep(3)
    response = requests.get(url)
    if response.status_code == 200:
        res = response.text
    else:
        res = '下载失败'
    return res


def parse(res):
    time.sleep(1)
    print('%s 解析结果为%s' % (os.getpid(), len(res)))


if __name__ == '__main__':
    urls = [
        'https://www.baidu.com',
        'https://www.sina.com.cn',
        'https://www.tmall.com',
        'https://www.jd.com',
        'https://www.python.org',
        'https://www.openstack.org',
        'https://www.baidu.com',
        'https://www.baidu.com',
        'https://www.baidu.com',

    ]

    p = ProcessPoolExecutor(9)
    l = []
    start = time.time()
    for url in urls:
        future = p.submit(get, url)
        l.append(future)
    p.shutdown(wait=True)

    for future in l:
        parse(future.result())

    print('完成时间', time.time() - start)

'''
6104 GET https://www.baidu.com
11096 GET https://www.sina.com.cn
6188 GET https://www.tmall.com
9224 GET https://www.jd.com
10376 GET https://www.python.org
7144 GET https://www.openstack.org
5516 GET https://www.baidu.com
9496 GET https://www.baidu.com
1100 GET https://www.baidu.com
14704 解析结果为2443
14704 解析结果为569114
14704 解析结果为233353
14704 解析结果为108550
14704 解析结果为48821
14704 解析结果为65099
14704 解析结果为2443
14704 解析结果为2443
14704 解析结果为2443
完成时间 19.062582969665527
'''

2-1-3 进程池的异步调用方式

'''
异步调用方式：
    缺点：存在耦合
    优点：速度快
'''
from concurrent.futures import ProcessPoolExecutor
import time, os
import requests


def get(url):
    print('%s GET %s' % (os.getpid(), url))
    time.sleep(3)
    response = requests.get(url)
    if response.status_code == 200:
        res = response.text
    else:
        res = '下载失败'
    parse(res)


def parse(res):
    time.sleep(1)
    print('%s 解析结果为%s' % (os.getpid(), len(res)))


if __name__ == '__main__':
    urls = [
        'https://www.baidu.com',
        'https://www.sina.com.cn',
        'https://www.tmall.com',
        'https://www.jd.com',
        'https://www.python.org',
        'https://www.openstack.org',
        'https://www.baidu.com',
        'https://www.baidu.com',
        'https://www.baidu.com',

    ]

    p = ProcessPoolExecutor(9)
    start = time.time()
    for url in urls:
        future = p.submit(get, url)
    p.shutdown(wait=True)

    print('完成时间', time.time() - start)

'''
11980 GET https://www.baidu.com
15308 GET https://www.sina.com.cn
14828 GET https://www.tmall.com
11176 GET https://www.jd.com
14792 GET https://www.python.org
14764 GET https://www.openstack.org
11096 GET https://www.baidu.com
13708 GET https://www.baidu.com
2080 GET https://www.baidu.com
14828 解析结果为233353
11176 解析结果为108569
11980 解析结果为2443
15308 解析结果为569124
11096 解析结果为2443
13708 解析结果为2443
2080 解析结果为2443
14764 解析结果为65099
14792 解析结果为48821
完成时间 7.404443979263306
'''

2-1-4 进程池,异步调用+回调函数：解决耦合，速度慢

'''
异步调用 + 回调函数 ：解决耦合,但速度慢
'''
from concurrent.futures import ProcessPoolExecutor
import time, os
import requests


def get(url):
    print('%s GET %s' % (os.getpid(), url))
    time.sleep(3)
    response = requests.get(url)
    if response.status_code == 200:
        res = response.text
    else:
        res = '下载失败'
    return res


def parse(future):
    time.sleep(1)
    # 传入的是个对象，获取返回值 需要进行result操作
    res = future.result()
    print('%s 解析结果为%s' % (os.getpid(), len(res)))


if __name__ == '__main__':
    urls = [
        'https://www.baidu.com',
        'https://www.sina.com.cn',
        'https://www.tmall.com',
        'https://www.jd.com',
        'https://www.python.org',
        'https://www.openstack.org',
        'https://www.baidu.com',
        'https://www.baidu.com',
        'https://www.baidu.com',

    ]

    p = ProcessPoolExecutor(9)
    start = time.time()
    for url in urls:
        future = p.submit(get, url)
        # 模块内的回调函数方法，parse会使用future对象的返回值，对象返回值是执行任务的返回值
        future.add_done_callback(parse)
    p.shutdown(wait=True)

    print('完成时间', time.time() - start)
'''
3960 GET https://www.baidu.com
14320 GET https://www.sina.com.cn
1644 GET https://www.tmall.com
196 GET https://www.jd.com
13512 GET https://www.python.org
7356 GET https://www.openstack.org
14952 GET https://www.baidu.com
9528 GET https://www.baidu.com
11940 GET https://www.baidu.com
15292 解析结果为233360
15292 解析结果为108543
15292 解析结果为2443
15292 解析结果为2443
15292 解析结果为2443
15292 解析结果为2443
15292 解析结果为569140
15292 解析结果为48821
15292 解析结果为65099
完成时间 14.311698913574219
'''

2-2 线程池：异步+回调 ---- IO密集型主要使用方式

'''线程池:执行操作为谁有空谁执行'''
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import time
import requests


def get(url):
    print('%s GET %s' % (current_thread().name, url))
    time.sleep(3)
    response = requests.get(url)
    if response.status_code == 200:
        res = response.text
    else:
        res = '下载失败'
    return res


def parse(future):
    time.sleep(1)
    res = future.result()
    print('%s 解析结果为%s' % (current_thread().name, len(res)))


if __name__ == '__main__':
    urls = [
        'https://www.baidu.com',
        'https://www.sina.com.cn',
        'https://www.tmall.com',
        'https://www.jd.com',
        'https://www.python.org',
        'https://www.openstack.org',
        'https://www.baidu.com',
        'https://www.baidu.com',
        'https://www.baidu.com',

    ]
    # 线程池内线程数
    p = ThreadPoolExecutor(4)
    start = time.time()
    for url in urls:
        future = p.submit(get, url)
        future.add_done_callback(parse)

    p.shutdown(wait=True)

    print('主', current_thread().name)
    print('完成时间', time.time() - start)

'''
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_0 GET https://www.baidu.com
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_1 GET https://www.sina.com.cn
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_2 GET https://www.tmall.com
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_3 GET https://www.jd.com
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_2 解析结果为233360
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_2 GET https://www.python.org
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_0 解析结果为2443
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_0 GET https://www.openstack.org
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_3 解析结果为108554
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_3 GET https://www.baidu.com
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_1 解析结果为569140
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_1 GET https://www.baidu.com
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_1 解析结果为2443
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_1 GET https://www.baidu.com
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_3 解析结果为2443
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_2 解析结果为48821
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_1 解析结果为2443
<concurrent.futures.thread.ThreadPoolExecutor object at 0x00000172EB2053C8>_0 解析结果为65099
主 MainThread
完成时间 14.592755317687988
'''

 

LSYHhhhh
关注
专栏目录
Python3线程池、进程池(concurrent.futures)
谢公子的博客
03-15 1958
Python3线程池，进程池使用的是concurrent.futures包 使用时，需导入 #线程池 from concurrent.futures import ThreadPoolExecutor #进程池 from concurrent.futures import ProcessPoolExecutor 正确使用线程池、进程池，如下。 from concurrent.fut...
Python3.2+ 的 concurrent.futures 模块
墨鱼菜鸡
07-11 440
concurrent.futures 官方文档：https://docs.python.org/3/library/concurrent.futures.html concurrent.futures: 线程池, 并发的处理任务：https://www.h3399.cn/201906/703751.html IO 密集型 vs计算密集型： IO密集...
python并发之concurrent.futures模块的使用
Ren_ger的博客
11-30 1159
Python标准库为我们提供了threading和multiprocessing模块编写相应的多线程/多进程代码。从Python3.2开始，标准库为我们提供了concurrent.futures模块，它提供了ThreadPoolExecutor和ProcessPoolExecutor两个类，实现了对threading和multiprocessing的更高级的抽象，对编写线程池/进程池提供了直接的支...
使用 Python 进行线程编程
半道出家的和尚
10-12 1039
引言对于 Python 来说，并不缺少并发选项，其标准库中包括了对线程、进程和异步 I/O 的支持。在许多情况下，通过创建诸如异步、线程和子进程之类的高层模块，Python 简化了各种并发方法的使用。除了标准库之外，还有一些第三方的解决方案，例如 Twisted、Stackless 和进程模块。本文重点关注于使用 Python 的线程，并使用了一些实际的示例进行说明。虽然有许多很好的联机资
python的线程池
最新发布
weixin_41978174的博客
08-26 509
在 Python 中，线程池是一种管理线程的机制，它可以重复利用已创建的线程来执行多个任务，避免频繁地创建和销毁线程所带来的开销。创建了一个线程池，最大线程数为 5。接着，通过循环提交了 10 个任务给线程池。函数，它接受一个任务编号作为参数，并打印出任务执行的信息。模块提供了线程池的实现。在上述代码中，首先定义了一个。函数获取已完成任务的结果。
Python3之concurrent.futures实现线程池，进程池
Quincy.Coder的博客
08-31 4729
关于concurrent.futures的官方文档concurrent.futures进程池代码演示from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor def deal_num(n): return n ** 2 if __name__ == '__main__': # 参数默认是CPU个数
python并发编程之进程池，线程池，协程
weixin_30342827的博客
08-29 199
需要注意一下 不能无限的开进程，不能无限的开线程 最常用的就是开进程池，开线程池。其中回调函数非常重要 回调函数其实可以作为一种编程思想，谁好了谁就去掉 只要你用并发，就会有锁的问题，但是你不能一直去自己加锁吧 那么我们就用QUEUE，这样还解决了自动加锁的问题 由Queue延伸出的一个点也非常重要的概念。以后写程序也会用到 这个思想。就是生产者与消费者问题 一、P...
python concurrent.futures模块并发，实现进程池、线程池
wto882dim的博客
03-13 626
使用concurrent.futures模块并发，实现进程池、线程池 阅读目录(Content) 一、关于concurrent.futures模块 二、submit()方法实现进程池/线程池 进程池 线程池 三、回调函数 四、map方法 回到顶部(go to top) 一、关于concurrent.futures模块 Python标准库为我们提供了threading和m...
Python标准模块--concurrent.futures模块（ThreadPoolExecutor：线程池，提供异步调用、ProcessPoolExecutor: 进程池，提供异步调用）
。
11-16 6122
目录 ProcessPoolExecutor: 进程池 ThreadPoolExecutor：线程池  map的用法  回调函数 https://docs.python.org/dev/library/concurrent.futures.html 1 介绍 concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor：线程池，提供异步调用...
Python concurrent.futures模块使用实例
12-23
concurrent.futures模块提供了使用工作线程或进程池运行任务的接口。线程和进程池API都是一样，所以应用只做最小的修改就可以在线程和进程之间地切换 1、基于线程池使用map() futures_thread_pool_map.py #!/usr/...
python3中线程池
dayan7727的博客
06-06 316
1.在使用多线程处理任务时也不是线程越多越好，由于在切换线程的时候，需要切换上下文环境，依然会造成cpu的大量开销。为解决这个问题，线程池的概念被提出来了。预先创建好一个较为优化的数量的线程，让过来的任务立刻能够使用，就形成了线程池。在python中，没有内置的较好的线程池模块，需要自己实现或使用第三方模块。下面是一个简单的线程池： import threading,time,os...
python concurrent.futures 中文文档
04-15
python concurrent.futures最新官网文档中文翻译，自己手动翻译，请勿喷。。。。。
python3线程池 多线程
qq_27886997的博客
09-27 1369
从Python3.2开始，标准库为我们提供了 concurrent.futures 模块，它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块，该模块通过 submit 返回的是一个 future 对象，它是一个未来可期的对象，通过它可以获悉线程的状态主线程(或进程)中可以获取某一个线程(进程)执行的状态或者某一个任务执行的状态及返回值： 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。 当一
python3多线程第三方库_Python3标准库：concurrent.futures管理并发任务池
weixin_39606137的博客
12-04 357
PythonPython开发Python语言Python3标准库：concurrent.futures管理并发任务池 1.concurrent.futures管理并发任务池concurrent.futures模块提供了使用工作线程或进程池运行任务的接口。线程和进程池的API是一样的，所以应用只做最小的修改就可以在线程和进程之间顺利地切换。这个模块提供了两种类型的类与这些池交...
python3 sleep 并发_Python3标准库：concurrent.futures管理并发任务池
weixin_34207787的博客
02-20 185
1.concurrent.futures管理并发任务池concurrent.futures模块提供了使用工作线程或进程池运行任务的接口。线程和进程池的API是一样的，所以应用只做最小的修改就可以在线程和进程之间顺利地切换。这个模块提供了两种类型的类与这些池交互。执行器(executor)用来管理工作线程或进程池，future用来管理工作线程或进程计算的结果。要使用一个工作线程或进程池，应用要创建...
Python实战：线程池：concurrent.futures模块
oandy0的博客
03-25 793
本文详细介绍了Python中的线程池：concurrent.futures模块的原理、使用方法以及在实际编程中的应用。通过具体代码示例，我们了解到线程池在Python编程中的重要性。掌握concurrent.futures模块对于编写高效、响应性好的Python程序至关重要。
python 线程池_《Python》线程池、携程
weixin_39654903的博客
12-02 147
一、线程池(concurrent.futures模块)#1 介绍concurrent.futures模块提供了高度封装的异步调用接口ThreadPoolExecutor：线程池，提供异步调用ProcessPoolExecutor: 进程池，提供异步调用Both implement the same interface, whichis defined by the abstract Executo...
使用concurrent.futures模块快捷方便的进行多线程(池)或多进程(池)操作(python)
keepaware的博客
09-20 897
本文从ThreadPoolExecutor 入手介绍了concurrent.futures模块的使用方式，内容包含了future对象、submit方法、map方法，as_completed、wait方法的使用方法。希望能帮到大家！
python3 模块_python3 线程池-threadpool模块与concurrent.futures模块
weixin_39814378的博客
01-29 241
一、 既然多线程可以缩短程序运行时间，那么，是不是线程数量越多越好呢？显然，并不是，每一个线程的从生成到消亡也是需要时间和资源的，太多的线程会占用过多的系统资源(内存开销，cpu开销)，而且生成太多的线程时间也是可观的，很可能会得不偿失，这里给出一个最佳线程数量的计算方式：最佳线程数的获取：1、通过用户慢慢递增来进行性能压测，观察QPS(即每秒的响应请求数，也即是最大吞吐能力。)，响应时间2、根据...
Python.concurrent.futures模块详解与使用示例
Python的`concurrent.futures`模块是用于并行执行异步操作的高级接口，它提供了一个统一的API来管理线程池和进程池，使得开发者可以在线程和进程之间轻松切换，而无需进行大量修改。这个模块在多核处理器环境下尤其...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值