python 线程池调用返回结果处理

laoli815

已于 2023-07-31 14:31:52 修改

阅读量3.3k

点赞数

分类专栏： Python基础教程文章标签： python java 开发语言

于 2022-07-08 12:18:14 首次发布

本文链接：https://blog.csdn.net/laoli815/article/details/125673969

版权

Python基础教程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

python多线程调用，如果使用threading.Thread这个如果没有返回值完全没问题，但是有返回的时候就很有问题
下面是一个sample

import  threading,os,time,datetime
def fun1(num):
    print(f"线程名称:{threading.current_thread().getName()},线程ID:{threading.get_ident()},进程ID:{os.getpid()},开始时间:{datetime.datetime.now()}")
    time.sleep(1)
    print(f"执行第{num}次fun1函数")
    print(f"线程名称:{threading.current_thread().getName()},线程ID:{threading.get_ident()},进程ID:{os.getpid()},结束时间:{datetime.datetime.now()}")

if __name__=='__main__':
    tasks=[]
    for i in range(10):
        t=threading.Thread(target=fun1,args=(i,))
        tasks.append(t)
        t.start()
    for i in tasks:
        i.join()

运行结果：

import  threading,os,time,datetime
def fun1(num):
    print(f"线程名称:{threading.current_thread().getName()},线程ID:{threading.get_ident()},进程ID:{os.getpid()},开始时间:{datetime.datetime.now()}")
    time.sleep(1)
    print(f"执行第{num}次fun1函数")
    print(f"线程名称:{threading.current_thread().getName()},线程ID:{threading.get_ident()},进程ID:{os.getpid()},结束时间:{datetime.datetime.now()}")

if __name__=='__main__':
    tasks=[]
    for i in range(10):
        t=threading.Thread(target=fun1,args=(i,))
        tasks.append(t)
        t.start()
    for i in tasks:
        i.join()

为了获取线程池执行的返回结果我们采用map方法

from concurrent.futures import  ThreadPoolExecutor
import  time,datetime
L1=[1,2,3,4,5,6,7,8,9,10]
L2=[1,2,3,4,5,6,7,8,9,10]
def add(a,b):
    print("============程序开始时间=============={}".format(datetime.datetime.now()))
    time.sleep(1)
    return a+b

if __name__=='__main__':
    with ThreadPoolExecutor(5) as t:
        res=t.map(add,L1,L2)
    print(res,type(res),list(res))
    print("============程序结束=============={}".format(datetime.datetime.now()))

返回结果：

============程序开始时间==============2022-07-08 10:48:45.342660
============程序开始时间==============2022-07-08 10:48:45.342957
============程序开始时间==============2022-07-08 10:48:45.343087
============程序开始时间==============2022-07-08 10:48:45.343184
============程序开始时间==============2022-07-08 10:48:45.343466
============程序开始时间==============2022-07-08 10:48:46.344016
============程序开始时间==============2022-07-08 10:48:46.344077
============程序开始时间==============2022-07-08 10:48:46.344096
============程序开始时间==============2022-07-08 10:48:46.344114
============程序开始时间==============2022-07-08 10:48:46.344211
<generator object Executor.map.<locals>.result_iterator at 0x7f99ae76df90> <class 'generator'> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
============程序结束==============2022-07-08 10:48:47.345554

这个map返回的结果集是根据执行顺序来的，为社么这么说，我们改写代码：

from concurrent.futures import  ThreadPoolExecutor
import  time,datetime
L1=[1,2,3,4,5,6,7,8,9,10]
L2=[1,2,3,4,5,6,7,8,9,10]
def add(a,b):
    print("============程序开始时间=============={}这是第{}个线程".format(datetime.datetime.now(),a))
    time.sleep(a%2)
    print("============程序结束时间=============={}这是第{}个线程".format(datetime.datetime.now(), a))
    return a+b
# def fn(res):
#     print(res.result())
#     return res.result()

if __name__=='__main__':
    with ThreadPoolExecutor(5) as t:
        res=t.map(add,L1,L2)
    print(res,type(res),list(res))
    print("============主程序结束=============={}".format(datetime.datetime.now()))

运行结果：

============程序开始时间==============2022-07-08 11:04:00.576773这是第1个线程
============程序开始时间==============2022-07-08 11:04:00.576998这是第2个线程
============程序结束时间==============2022-07-08 11:04:00.577011这是第2个线程
============程序开始时间==============2022-07-08 11:04:00.577155这是第3个线程
============程序开始时间==============2022-07-08 11:04:00.577264这是第4个线程
============程序结束时间==============2022-07-08 11:04:00.577276这是第4个线程
============程序开始时间==============2022-07-08 11:04:00.577360这是第5个线程
============程序开始时间==============2022-07-08 11:04:00.577479这是第6个线程
============程序结束时间==============2022-07-08 11:04:00.577490这是第6个线程
============程序开始时间==============2022-07-08 11:04:00.577574这是第7个线程
============程序开始时间==============2022-07-08 11:04:00.577703这是第8个线程
============程序结束时间==============2022-07-08 11:04:00.577714这是第8个线程
============程序开始时间==============2022-07-08 11:04:00.577776这是第9个线程
============程序结束时间==============2022-07-08 11:04:01.578215这是第1个线程
============程序开始时间==============2022-07-08 11:04:01.578312这是第10个线程
============程序结束时间==============2022-07-08 11:04:01.578322这是第10个线程
============程序结束时间==============2022-07-08 11:04:01.578513这是第3个线程
============程序结束时间==============2022-07-08 11:04:01.578551这是第5个线程
============程序结束时间==============2022-07-08 11:04:01.578581这是第7个线程
============程序结束时间==============2022-07-08 11:04:01.578697这是第9个线程
<generator object Executor.map.<locals>.result_iterator at 0x7f32e0394f20> <class 'generator'> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
============主程序结束==============2022-07-08 11:04:01.578848

返回结果依旧是根据线程的顺序来的，很好
返回结果调用第二种方式：

from concurrent.futures import  ThreadPoolExecutor
import  time,datetime
L1=[1,2,3,4,5,6,7,8,9,10]
L2=[1,2,3,4,5,6,7,8,9,10]
def add(a,b):
    print("============程序开始时间=============={}这是第{}个线程".format(datetime.datetime.now(),a))
    time.sleep(a%2)
    print("============程序结束时间=============={}这是第{}个线程".format(datetime.datetime.now(), a))
    return a+b
def fn(res):
    print(res.result())
    return res.result()

if __name__=='__main__':
    result=[]
    with ThreadPoolExecutor(5) as t:
        for p in list(zip(L1,L2)):
            result.append(t.submit(lambda p:add(*p),p).add_done_callback(fn))
    print(result)
    print("============主程序结束=============={}".format(datetime.datetime.now()))

执行结果：

============程序开始时间==============2022-07-08 12:02:07.713207这是第1个线程
============程序开始时间==============2022-07-08 12:02:07.713511这是第2个线程
============程序结束时间==============2022-07-08 12:02:07.713525这是第2个线程
4
============程序开始时间==============2022-07-08 12:02:07.713625这是第3个线程
============程序开始时间==============2022-07-08 12:02:07.713739这是第4个线程
============程序结束时间==============2022-07-08 12:02:07.713751这是第4个线程
8
============程序开始时间==============2022-07-08 12:02:07.713844这是第5个线程
============程序开始时间==============2022-07-08 12:02:07.713927这是第6个线程
============程序结束时间==============2022-07-08 12:02:07.713974这是第6个线程
12
============程序开始时间==============2022-07-08 12:02:07.714068这是第7个线程
============程序开始时间==============2022-07-08 12:02:07.714195这是第8个线程
============程序结束时间==============2022-07-08 12:02:07.714206这是第8个线程
16
============程序开始时间==============2022-07-08 12:02:07.714277这是第9个线程
============程序结束时间==============2022-07-08 12:02:08.714232这是第1个线程
2
============程序开始时间==============2022-07-08 12:02:08.714339这是第10个线程
============程序结束时间==============2022-07-08 12:02:08.714350这是第10个线程
20
============程序结束时间==============2022-07-08 12:02:08.714556这是第3个线程
6
============程序结束时间==============2022-07-08 12:02:08.714605这是第5个线程
10
============程序结束时间==============2022-07-08 12:02:08.714646这是第7个线程
14
============程序结束时间==============2022-07-08 12:02:08.714819这是第9个线程
18
[None, None, None, None, None, None, None, None, None, None]
============主程序结束==============2022-07-08 12:02:08.714934

这个先后执行顺序不做保证，和Thread类似
本案例add使用了两个变量，迭代的时候需要使用lambda函数，然后在通过可变变量*的方式传入值，很神奇这种方法
返回结果调用第三种方法：

from concurrent.futures import  ThreadPoolExecutor
import  time,datetime
L1=[1,2,3,4,5,6,7,8,9,10]
L2=[1,2,3,4,5,6,7,8,9,10]
def add(a,b):
    print("============程序开始时间=============={}这是第{}个线程".format(datetime.datetime.now(),a))
    time.sleep(a%2)
    print("============程序结束时间=============={}这是第{}个线程".format(datetime.datetime.now(), a))
    return a+b
if __name__=='__main__':
    result=[]
    with ThreadPoolExecutor(5) as t:
        for p in list(zip(L1,L2)):
            result.append(t.submit(lambda p:add(*p),p))
    for i in result:
        print(i.result())
    print("============主程序结束=============={}".format(datetime.datetime.now()))

执行

============程序开始时间==============2022-07-08 12:59:50.259288这是第1个线程
============程序开始时间==============2022-07-08 12:59:50.259593这是第2个线程
============程序结束时间==============2022-07-08 12:59:50.259608这是第2个线程
============程序开始时间==============2022-07-08 12:59:50.259704这是第3个线程
============程序开始时间==============2022-07-08 12:59:50.259787这是第4个线程
============程序结束时间==============2022-07-08 12:59:50.259837这是第4个线程
============程序开始时间==============2022-07-08 12:59:50.259929这是第5个线程
============程序开始时间==============2022-07-08 12:59:50.260012这是第6个线程
============程序结束时间==============2022-07-08 12:59:50.260023这是第6个线程
============程序开始时间==============2022-07-08 12:59:50.260146这是第7个线程
============程序开始时间==============2022-07-08 12:59:50.260258这是第8个线程
============程序结束时间==============2022-07-08 12:59:50.260270这是第8个线程
============程序开始时间==============2022-07-08 12:59:50.260407这是第9个线程
============程序结束时间==============2022-07-08 12:59:51.260545这是第1个线程
============程序开始时间==============2022-07-08 12:59:51.260651这是第10个线程
============程序结束时间==============2022-07-08 12:59:51.260664这是第10个线程
============程序结束时间==============2022-07-08 12:59:51.260868这是第3个线程
============程序结束时间==============2022-07-08 12:59:51.260912这是第5个线程
============程序结束时间==============2022-07-08 12:59:51.260945这是第7个线程
============程序结束时间==============2022-07-08 12:59:51.261080这是第9个线程
2
4
6
8
10
12
14
16
18
20
============主程序结束==============2022-07-08 12:59:51.261224

使用了with方法默认要等线程执行完毕才能运行最下面的主程序结束
代码在改变下

from concurrent.futures import  ThreadPoolExecutor
import  time,datetime
L1=[1,2,3,4,5,6,7,8,9,10]
L2=[1,2,3,4,5,6,7,8,9,10]
def add(a,b):
    print("============程序开始时间=============={}这是第{}个线程".format(datetime.datetime.now(),a))
    time.sleep(a%2)
    print("============程序结束时间=============={}这是第{}个线程".format(datetime.datetime.now(), a))
    return a+b
def fn(res):
    print(res.result())
    return res.result()

if __name__=='__main__':
    # with ThreadPoolExecutor(5) as t:
    #     res=t.map(add,L1,L2)
    # print(res,type(res),list(res))
    # print("============主程序结束=============={}".format(datetime.datetime.now()))
    result=[]
    # with ThreadPoolExecutor(5) as t:
    #     for p in list(zip(L1,L2)):
    #         result.append(t.submit(lambda p:add(*p),p).add_done_callback(fn))
    # print(result)
    t=ThreadPoolExecutor(max_workers=5)
    for p in list(zip(L1, L2)):
        result.append(t.submit(lambda p:add(*p),p).add_done_callback(fn))
    # t.shutdown()
    print("============主程序结束=============={}".format(datetime.datetime.now()))

运行结果

============程序开始时间==============2022-07-08 12:15:02.978244这是第1个线程
============程序开始时间==============2022-07-08 12:15:02.978540这是第2个线程
============程序结束时间==============2022-07-08 12:15:02.978554这是第2个线程
4
============程序开始时间==============2022-07-08 12:15:02.978653这是第3个线程
============程序开始时间==============2022-07-08 12:15:02.978771这是第4个线程
============程序结束时间==============2022-07-08 12:15:02.978784这是第4个线程
8
============程序开始时间==============2022-07-08 12:15:02.978877这是第5个线程
============程序开始时间==============2022-07-08 12:15:02.978991这是第6个线程
============程序结束时间==============2022-07-08 12:15:02.979003这是第6个线程
12
============程序开始时间==============2022-07-08 12:15:02.979094这是第7个线程
============程序开始时间==============2022-07-08 12:15:02.979204这是第8个线程
============程序结束时间==============2022-07-08 12:15:02.979216这是第8个线程
16
============主程序结束==============2022-07-08 12:15:02.979256
============程序开始时间==============2022-07-08 12:15:02.979309这是第9个线程
============程序结束时间==============2022-07-08 12:15:03.979889这是第1个线程
2
============程序开始时间==============2022-07-08 12:15:03.980001这是第10个线程
============程序结束时间==============2022-07-08 12:15:03.980013这是第10个线程
20
============程序结束时间==============2022-07-08 12:15:03.980232这是第3个线程
6
============程序结束时间==============2022-07-08 12:15:03.980283这是第5个线程
10
============程序结束时间==============2022-07-08 12:15:03.980326这是第7个线程
14
============程序结束时间==============2022-07-08 12:15:03.980469这是第9个线程
18

注意下主程序结束==2022-07-08 12:15:02.979256 这个没有等线程结束就执行了，和只有start()没有join的一样，这种方式等着结束，需要这样写

from concurrent.futures import  ThreadPoolExecutor
import  time,datetime
L1=[1,2,3,4,5,6,7,8,9,10]
L2=[1,2,3,4,5,6,7,8,9,10]
def add(a,b):
    print("============程序开始时间=============={}这是第{}个线程".format(datetime.datetime.now(),a))
    time.sleep(a%2)
    print("============程序结束时间=============={}这是第{}个线程".format(datetime.datetime.now(), a))
    return a+b
def fn(res):
    print(res.result())
    return res.result()

if __name__=='__main__':
    # with ThreadPoolExecutor(5) as t:
    #     res=t.map(add,L1,L2)
    # print(res,type(res),list(res))
    # print("============主程序结束=============={}".format(datetime.datetime.now()))
    result=[]
    # with ThreadPoolExecutor(5) as t:
    #     for p in list(zip(L1,L2)):
    #         result.append(t.submit(lambda p:add(*p),p).add_done_callback(fn))
    # print(result)
    t=ThreadPoolExecutor(max_workers=5)
    for p in list(zip(L1, L2)):
        result.append(t.submit(lambda p:add(*p),p).add_done_callback(fn))
    t.shutdown()
    print("============主程序结束=============={}".format(datetime.datetime.now()))

运行结果

from concurrent.futures import  ThreadPoolExecutor
import  time,datetime
L1=[1,2,3,4,5,6,7,8,9,10]
L2=[1,2,3,4,5,6,7,8,9,10]
def add(a,b):
    print("============程序开始时间=============={}这是第{}个线程".format(datetime.datetime.now(),a))
    time.sleep(a%2)
    print("============程序结束时间=============={}这是第{}个线程".format(datetime.datetime.now(), a))
    return a+b
def fn(res):
    print(res.result())
    return res.result()

if __name__=='__main__':
    # with ThreadPoolExecutor(5) as t:
    #     res=t.map(add,L1,L2)
    # print(res,type(res),list(res))
    # print("============主程序结束=============={}".format(datetime.datetime.now()))
    result=[]
    # with ThreadPoolExecutor(5) as t:
    #     for p in list(zip(L1,L2)):
    #         result.append(t.submit(lambda p:add(*p),p).add_done_callback(fn))
    # print(result)
    t=ThreadPoolExecutor(max_workers=5)
    for p in list(zip(L1, L2)):
        result.append(t.submit(lambda p:add(*p),p).add_done_callback(fn))
    t.shutdown()
    print("============主程序结束=============={}".format(datetime.datetime.now()))