# -*- coding: utf-8 -*-

 # (C) Guangcai Ren <renguangcai@jiaaocap.com>

 # All rights reserved

 # create time '2019/6/26 14:41'

 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)

 def use():

     split_df()

 if __name__ == '__main__':

     y = use()

     print(len(_result_list), _result_list)

# -*- coding: utf-8 -*-

# (C) Guangcai Ren <renguangcai@jiaaocap.com>

# All rights reserved

# create time '2019/6/26 14:41'

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():

    pool = ThreadPoolExecutor(max_workers=5)

    new_list, count_list = split_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返回的结果 是 有序结果；是根据迭代函数执行顺序返回的结果

    # 使用map的优点是 每次调用回调函数的结果不用手动的放入结果list中

    results = pool.map(work, new_list, count_list)

    print(type(results))

    # 如下2行 会等待线程任务执行结束后 再执行其他代码

    for ret in results:

        print(ret)

    print('thread execute end!')

if __name__ == '__main__':

    use()

 # -*- coding: utf-8 -*-

 # (C) Guangcai Ren <renguangcai@jiaaocap.com>

 # All rights reserved

 # create time '2019/6/26 14:41'

 import math

 import random

 import time

 from concurrent.futures import ThreadPoolExecutor

 # 线程池list

 pool_list = []

 def split_df(pool):

     # 需要处理的数据

     _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]

         # 线程相关处理

         # submit方法提交可回调的函数，并返回一个future实例；future对象包含相关属性

         # 如: done(函数是否执行完成),result(函数执行结果),running(函数是否正在运行)

         # 从而 可以在submit 后的代码中 查看 相关任务运行情况

         # 此方法 执行数据的结果是无序的，如果需要得到有序的结果，需要 for循环 每个future实例(线程池)，如 此脚本代码

         f = pool.submit(work, item, _list)

         pool_list.append(f)

         count += split_count

 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():

     pool = ThreadPoolExecutor(max_workers=5)

     split_df(pool)

     _result_list = []

     for item in pool_list:

         result_tuple = item.result()

         _result_list.append(result_tuple[1])

     return _result_list

 if __name__ == '__main__':

     _result_list = use()

     print(len(_result_list), _result_list)