python多线程之threading、ThreadPoolExecutor.map

背景：

（多线程执行同一个函数任务）某个应用场景需要从数据库中取出几十万的数据时，需要对每个数据进行相应的操作。逐个数据处理过慢，于是考虑对数据进行分段线程处理：

• 方法一：使用threading模块

代码：

 # -*- coding: utf-8 -*-
 import math
 import random
 import time
 from threading import Thread

 _result_list = []

 def split_df():
     # 线程列表
     thread_list = []
     # 需要处理的数据
     _l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     # 每个线程处理的数据大小
     split_count = 2
     # 需要的线程个数
     times = math.ceil(len(_l) / split_count)
     count = 0
     for item in range(times):
         _list = _l[count: count + split_count]
         # 线程相关处理
         thread = Thread(target=work, args=(item, _list,))
         thread_list.append(thread)
         # 在子线程中运行任务
         thread.start()
         count += split_count

     # 线程同步，等待子线程结束任务，主线程再结束
     for _item in thread_list:
         _item.join()

 def work(df, _list):
     """
     每个线程执行的任务，让程序随机sleep几秒
     :param df:
     :param _list:
     :return:
     """
     sleep_time = random.randint(1, 5)
     print(f'count is {df},sleep {sleep_time},list is {_list}')
     time.sleep(sleep_time)
     _result_list.append(df)

 if __name__ == '__main__':
     split_df()
     print(len(_result_list), _result_list)

测试结果：

• 方法二：使用ThreadPoolExecutor.map

代码：

 # -*- coding: utf-8 -*-
 import math
 import random
 import time
 from concurrent.futures import ThreadPoolExecutor

 def split_list():
     # 线程列表
     new_list = []
     count_list = []
     # 需要处理的数据
     _l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     # 每个线程处理的数据大小
     split_count = 2
     # 需要的线程个数
     times = math.ceil(len(_l) / split_count)
     count = 0
     for item in range(times):
         _list = _l[count: count + split_count]
         new_list.append(_list)
         count_list.append(count)
         count += split_count
     return new_list, count_list

 def work(df, _list):
     """ 线程执行的任务，让程序随机sleep几秒
     :param df:
     :param _list:
     :return:
     """
     sleep_time = random.randint(1, 5)
     print(f'count is {df},sleep {sleep_time},list is {_list}')
     time.sleep(sleep_time)
     return sleep_time, df, _list

 def use():
     new_list, count_list = split_list()
     with ThreadPoolExecutor(max_workers=len(count_list)) as t:
         results = t.map(work, new_list, count_list)

     # 或执行如下两行代码
     # pool = ThreadPoolExecutor(max_workers=5)
     # 使用map的优点是 每次调用回调函数的结果不用手动的放入结果list中
     # results = pool.map(work, new_list, count_list)

     # map返回一个迭代器，其中的回调函数的参数 最好是可以迭代的数据类型，如list；如果有 多个参数 则 多个参数的 数据长度相同；
     # 如： pool.map(work,[[1,2],[3,4]],[0,1]]) 中 [1,2]对应0 ；[3,4]对应1 ；其实内部执行的函数为 work([1,2],0) ; work([3,4],1)
     # map返回的结果 是 有序结果；是根据迭代函数执行顺序返回的结果
     print(type(results))
     # 如下2行 会等待线程任务执行结束后 再执行其他代码
     for ret in results:
         print(ret)
     print('thread execute end!')

 if __name__ == '__main__':
     use()

测试结果：

参考链接：https://www.cnblogs.com/rgcLOVEyaya/p/RGC_LOVE_YAYA_1103_3days.html