python 线程池，进程池

进程池/线程池  

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.")