线程池

# concurrent.futures模块提供了高度封装的异步调用接口。
    # 其中ThreadPoolExecutor：线程池，提供异步调用
    # 其中ProcessPooExecutor：进程池，提供异步调用。之前学过multiprocessing中的Pool也是进程池。
# 在这个concurrent.futures模块中，线程池与进程池的所有方法接口都是相同的

# 基本方法
    # submit(fn, *args, **kwargs)   异步提交任务

    # map(func, *iterable, timeout=None, chunksize = 1) 取代for循环submit操作

    # shutdown(wait=True)   相当于进程池的pool.close() + pool.join()操作
        # wait=True，等待池内所有任务执行完毕回收完资源后才继续
        # wait=False，立即返回，并会等待池内的任务执行完毕
        # 不管wait参数为何值，整个程序都会等到所有任务执行完毕
        # submit和map必须在shutdown之前

    # result(timeout=None)  # 取得结果

    # add_done_callback(fn) # 回调函数


# import time
# from concurrent.futures import ThreadPoolExecutor   # 导入线程池模块
#
# def func(n):
#     time.sleep(0.5)
#     print(n)
#     return n
#
# def my_call_back(n):
#     print('回调 ', n)
#
# if __name__ == '__main__':
#     tpool = ThreadPoolExecutor(max_workers=5)  # 创建一个线程池，池子里存放5个线程，效率最好的话，这个参数还是为CPU数*5比较好些
#     t_lst = []
#     for i in range(20):
#         t = tpool.submit(func, i)  # 异步提交任务到线程池中，让线程池开始调度,此时已经开始调度执行了.提交任务时，返回得到一个结果对象
#         t_lst.append(t)
#
#     tpool.shutdown()    # 阻塞等待池子中所有的任务全部结束执行完。相当于进程池中的pool.close()和pool.join()
#     print('线程池中的任务执行结束')
#     for t in t_lst:
#         print('***', t.result())    # 通过提交任务到线程池中的方法返回得到的结果对象，从而获取到任务的返回值


# # 使用concurrent.futures模块中的进程池
# import time
# from concurrent.futures import ThreadPoolExecutor   # 导入线程池模块
# from concurrent.futures import ProcessPoolExecutor  # 导入进程池模块， 只需将创建线程那里改为创建进程即可
#
# def func(n):
#     time.sleep(0.5)
#     print(n)
#     return n
#
# def my_call_back(n):
#     print('回调 ', n)
#
# if __name__ == '__main__':
#     tpool = ProcessPoolExecutor(max_workers=5)  # 创建一个进程池
#     t_lst = []
#     for i in range(20):
#         t = tpool.submit(func, i)  # 异步提交任务，提交任务时，返回得到一个结果对象
#         t_lst.append(t)
#
#     tpool.shutdown()    # 阻塞等待池子中所有的任务全部结束执行完。相当于进程池中的pool.close()和pool.join()
#     print('线程池中的任务执行结束')
#     for t in t_lst:
#         print('***', t.result())    # 通过结果对象，从而获取到任务的返回值
#         t.add_done_callback(my_call_back)


# # 使用线程池中的map
# import time
# from concurrent.futures import ThreadPoolExecutor   # 导入线程池模块
#
# def func(n):
#     time.sleep(0.5)
#     print(n)
#     return n
#
# def my_call_back(n):
#     print('回调 ', n)
#
# if __name__ == '__main__':
#     tpool = ThreadPoolExecutor(max_workers=5)  # 创建一个线程池，池子里存放5个线程，效率最好的话，这个参数还是为CPU数*5比较好些
#     tpool.map(func, range(20))  # 使用map，提交任务到线程池中，就拿不到任务的返回结果对象了
#
#     tpool.shutdown()    # 阻塞等待池子中所有的任务全部结束执行完。相当于进程池中的pool.close()和pool.join()
#     print('线程池中的任务执行结束')


# 使用结果对象的阻塞效果
# import time
# from concurrent.futures import ThreadPoolExecutor   # 导入线程池模块
#
# def func(n):
#     time.sleep(0.5)
#     print(n)
#     return n
#
# if __name__ == '__main__':
#     tpool = ThreadPoolExecutor(max_workers=5)  # 创建一个线程池，池子里存放5个线程，效率最好的话，这个参数还是为CPU数*5比较好些
#     t_lst = []
#     for i in range(20):
#         t = tpool.submit(func, i)  # 异步提交任务到线程池中，让线程池开始调度,此时已经开始调度执行了.提交任务时，返回得到一个结果对象
#         t_lst.append(t)
#
#     for t in t_lst:
#         print('***', t.result())    # 通过提交任务到线程池中的方法返回得到的结果对象，从而获取到任务的返回值,阻塞在这里等待执行完的任务然后拿到执行完任务的返回结果。所有任务执行结束后这里解除阻塞
#
#     print('线程池中的任务执行结束，得到了所有返回值')


# 线程池中的回调函数
import time
from concurrent.futures import ThreadPoolExecutor   # 导入线程池模块

def func(n):
    time.sleep(0.5)
    print(n)
    return n

def call_back(n):
    print('回调', n.result()) # 得到任务返回的结果，返回是结果对象，所以要result()才可得到任务的返回值

if __name__ == '__main__':
    tpool = ThreadPoolExecutor(max_workers=5)  # 创建一个线程池，池子里存放5个线程，效率最好的话，这个参数还是为CPU数*5比较好些
    for i in range(20):
        tpool.submit(func, i).add_done_callback(call_back)  # 异步提交任务到线程池中，让线程池开始调度,同时指定了回调函数，此时已经开始调度执行了.

    tpool.shutdown()
    print('线程池中的任务执行结束，得到了所有返回值')