python3 进程池和线程池

进程池的使用实例

import time
from concurrent.futures import ProcessPoolExecutor


def func(name):
    print(f"{name}开始")
    time.sleep(0.5)
    print(f"{name}结束")


if __name__ == '__main__':
    p = ProcessPoolExecutor(max_workers=3)  # 创建一个进程池
    for i in range(1, 10):
        p.submit(func, f"进程{i}")  # 往进程池内提交任务

    p.shutdown()  # 主进程等待子进程结束
    print("主进程结束")

执行结果：

进程1开始
进程2开始
进程3开始
进程1结束
进程4开始
进程2结束
进程5开始
进程3结束
进程6开始
进程4结束
进程7开始
进程5结束
进程8开始
进程6结束
进程9开始
进程7结束
进程8结束
进程9结束
主进程结束

创建一个进程池，进程池里有3个进程同时在执行任务，哪个进程执行完了，会自动执行下一个任务，相当于原来是一个人干活，现在是3个人一起干活，速度会提高很多。

线程池的使用实例

import time
from concurrent.futures import ThreadPoolExecutor


def func(name):
    print(f"{name}开始")
    time.sleep(0.5)
    print(f"{name}结束")


if __name__ == '__main__':
    p = ThreadPoolExecutor(max_workers=3)  # 创建一个线程池，里面最多有3个线程同时工作
    for i in range(1, 10):
        p.submit(func, f"线程{i}")
    p.shutdown()  # 主线程等待子线程结束
    print("主线程结束")

执行结果：

线程1开始
线程2开始
线程3开始
线程3结束
线程1结束
线程2结束
线程4开始
线程5开始
线程6开始
线程5结束
线程4结束
线程6结束
线程7开始
线程8开始
线程9开始
线程7结束
线程8结束
线程9结束
主线程结束

创建一个线程池，线程池里有3个线程同时在执行任务，哪个线程执行完了，会自动执行下一个任务，相当于原来是一个人干活，现在是3个人一起干活，速度会提高很多。

对比看下线程池和进程池（用法完全一样）

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


def f(n):
    time.sleep(random.randint(1, 3))
    # print(n)
    # print("进程(%s) %s的平方: %s" % (os.getpid(), n, n*n))
    print("线程(%s) %s的平方: %s" % (threading.current_thread().getName(), n, n * n))
    return n * n


if __name__ == '__main__':

    pool = ThreadPoolExecutor(max_workers=5)
    # pool = ProcessPoolExecutor(max_workers=5)
    ret_list = []
    for i in range(10):
        ret = pool.submit(f, i)  # 异步提交任务,f函数名称或者方法名称,i给f函数的参数
        # print(ret.result())  #join
        ret_list.append(ret)

    # pool.shutdown()  #锁定线程池,不让新任务再提交进来了.轻易不用
    for i in ret_list:
        print(i.result())

执行结果：

线程(ThreadPoolExecutor-0_2) 2的平方: 4
线程(ThreadPoolExecutor-0_3) 3的平方: 9
线程(ThreadPoolExecutor-0_1) 1的平方: 1
线程(ThreadPoolExecutor-0_0) 0的平方: 0
线程(ThreadPoolExecutor-0_2) 5的平方: 25
0
1
4
9
线程(ThreadPoolExecutor-0_4) 4的平方: 16
16
25
线程(ThreadPoolExecutor-0_3) 6的平方: 36
36
线程(ThreadPoolExecutor-0_1) 7的平方: 49
线程(ThreadPoolExecutor-0_2) 9的平方: 81
49
线程(ThreadPoolExecutor-0_0) 8的平方: 64
64
81

接下来再看一个实例(add_done_callback回调)

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


def f(n):
    time.sleep(random.randint(1, 3))
    return n * n


def call_back(m):
    print(m)
    print(m.result())


if __name__ == '__main__':
    pool = ThreadPoolExecutor(max_workers=5)
    pool.submit(f, 2).add_done_callback(call_back)

执行结果：

<Future at 0x2998208 state=finished returned int>
4

带有回调函数的进程池

from concurrent.futures import ProcessPoolExecutor


def func(name):
    print(name)
    return 123


def callback(res):
    print("结束了一个", res.result())


if __name__ == '__main__':
    p = ProcessPoolExecutor(3)
    for i in range(5):
        # 添加到进程池，开启该进程，并设置回调，当func结束的时候，自动执行callback,并可以直接拿到func函数执行的返回值
        p.submit(func, f"进程{i}").add_done_callback(callback)
    print("主进程")

 执行结果：

主进程
进程0
进程1
结束了一个 123
进程2
进程3
结束了一个 123
进程4
结束了一个 123
结束了一个 123
结束了一个 123