python 线程池，进程池

原创已于 2023-11-30 14:16:59 修改 · 1k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#python

于 2020-01-27 10:25:45 首次发布

并发编程专栏收录该内容

21 篇文章

订阅专栏

本文深入探讨Python中的进程池和线程池应用，讲解如何利用concurrent.futures模块有效管理和调度进程与线程，实现资源的最大化利用，同时确保系统的稳定性和安全性。通过实例演示，展示了异步任务提交、结果回收及回调函数的使用，为读者提供了实践指导。

进程池/线程池

python2 线程池

开进程开线程都需要消耗资源,只不过两者比较的情况下线程的资源消耗的较小

所以我们要在计算机能够承受的范围内最大限度的利用计算机

在保证计算机硬件的安全情况下最大限度的利用计算机的资源
池其实是降低了程序的运行效率,但是保证了计算机硬件的安全

concurrent.futures 模块

pool = ProcessPoolExecutor() 进程池 括号内可以传参数指定进程个数,默认cpu个数 提供异步调用
pool = ThreadPoolExecutor() 线程池 括号内可以传参数指定线程个数,默认cpu*5个 提供异步调用

池子中创建的进程/线程创建一次就不会创建了,至始至终用的都是最初的默认或自定义的那几个,这样节省了反复开辟进程/线程资源

pool.submit(fn, *args, **kwargs ) 向线程/进程内提交任务异步提交

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

# 实例化进程池
pool = ProcessPoolExecutor()  # 括号内可以传参数指定池的个数,进程池默认是cpu个数
# 实例化线程池
# pool = ThreadPoolExecutor()

def task(n):
    print('%s running'%n, os.getpid())
    time.sleep(3)
    print('%s over'%n)
    return n**2

if __name__ == '__main__':
    pool.submit(task, 1)  # 向进程池/线程池内提交任务  异步提交
    print('主 进程/线程')

result() 原地等待任务的返回结果

# 实例化进程池
# pool = ProcessPoolExecutor()
# 实例化线程池
pool = ThreadPoolExecutor(5)

def task(n):
    print('%s running'%n, os.getpid())
    time.sleep(3)
    # print('%s over'%n)
    return n**2

if __name__ == '__main__':
    for i in range(3):
        res = pool.submit(task, i)
        print('>>>:', res.result())  # 原地等待任务的返回结果(return 的结果)
 >>>
0 running 3664
>>>:0
1 running 3664
>>>:1
2 running 3664
>>>:4

pool.shutdown() 关闭池子,等待池子中的所有任务执行完毕后再走下面得我代码

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

pool = ThreadPoolExecutor(5)

def task(n):
    print('%s running'%n, os.getpid())
    time.sleep(3)
    # print('%s over'%n)
    return n**2

if __name__ == '__main__':
    lists = []
    for i in range(3):
        res = pool.submit(task, i)  # 异步提交任务
        lists.append(res)
    pool.shutdown()  # 关闭池子,等待池子中的所有任务执行完毕后再走下面得代码
    for p in lists:
        print('>>>:', p.result())
 >>>
0 running 12168
1 running 12168
2 running 12168
>>>: 0
>>>: 1
>>>: 4

add_done_callback (func) 回调函数

# 实例化进程池
# pool = ProcessPoolExecutor()
# 实例化线程池
pool = ThreadPoolExecutor(5)

def task(n):
    print('%s running'%n, os.getpid())
    time.sleep(3)
    # print('%s over'%n)
    return n**2

def call_back(n):
    print('异步提交任务的返回结果:', n.result())

if __name__ == '__main__':
    for i in range(10):
        res = pool.submit(task, i).add_done_callback(call_back) # 提交任务的时候,绑定一个回调函数,一旦该任务有结果,立刻执行对应的回调函数
>>>
0 running 8488
1 running 8488
2 running 8488
3 running 8488
4 running 8488
异步提交任务的返回结果: 0
5 running 8488
异步提交任务的返回结果: 1
6 running 8488
异步提交任务的返回结果: 4
7 running 8488
异步提交任务的返回结果: 9
8 running 8488
异步提交任务的返回结果: 16
9 running 8488
异步提交任务的返回结果: 36
异步提交任务的返回结果: 25
异步提交任务的返回结果: 64
异步提交任务的返回结果: 49
异步提交任务的返回结果: 81

import concurrent.futures
import queue
import threading

# 定义任务处理函数
def task_handler(arg1, arg2):
    print(f"Start processing task with arguments: {arg1}, {arg2}")
    # 模拟长时间任务
    time.sleep(10)
    print("Task processed.")


# 创建进程池和队列
executor = concurrent.futures.ProcessPoolExecutor()
task_queue = queue.Queue()

# 创建专门的线程获取任务并交给进程池处理
def task_consumer():
    while True:
        try:
            # 从队列中获取任务
            task = task_queue.get(timeout=1)
        except queue.Empty:
            # 如果队列为空，等待一段时间后再次尝试获取
            continue

        # 提交任务给进程池执行
        future = executor.submit(task_handler, *task)
        # 在任务执行完成后处理结果，例如写入数据库等操作
        future.add_done_callback(handle_result)
        # 标记任务已完成处理
        task_queue.task_done()

# 创建任务执行结果处理函数
def handle_result(future):
    result = future.result()
    # 处理任务执行结果，例如写入数据库等操作
    # ...

# 启动任务消费者线程
consuming_thread = threading.Thread(target=task_consumer, daemon=True)
consuming_thread.start()

# Django 视图函数
def your_view_function(request):
    # 将任务添加到队列中
    task_queue.put((arg1, arg2))

    # 返回响应或执行其他操作
    return HttpResponse("Task added to queue.")