池

池
    在程序开始的时候，还没提交任务先创建几个线程或者进程
    放在一个池子里，就是池
为什么要用池
    如果先开好线程/进程，那么有任务之后就可以直接使用这个池中的数据了
    并且开好的线程或者进程会一直存在池中，可以被多个任务反复利用
        这样极大的减少了开启/关闭/调度线程/进程的时间
    池中的线程/进程个数控制了操作系统需要调度的任务个数，控制池中的单位
        有利于提高操作系统的效率，减轻操作系统负担


实例化 创建池
向池中提交任务，submit 传参数（按照位置传，按照关键字传）

# 线程池
# import time
# import random
# from threading import current_thread
# from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
#
# def func():
#     print(current_thread().ident, "开始")
#     time.sleep(random.randint(1, 4))
#     print(current_thread().ident, "结束")
#
# tp = ThreadPoolExecutor(4)
# for i in range(20):
#     tp.submit(func)





# 进程池
# import os
# import time
# import random
# from threading import current_thread
# from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
#
# def func():
#     print(os.getpid(), "开始")
#     time.sleep(random.randint(1, 4))
#     print(os.getpid(), "结束")
#
# if __name__ == "__main__":
#     tp = ProcessPoolExecutor(4)
#     for i in range(20):
#         tp.submit(func)



# 获取任务结果
# import os
# import time
# import random
# from threading import current_thread
# from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
#
# def func(a ,b):
#     print(os.getpid(), "开始", a, b)
#     time.sleep(random.randint(1, 4))
#     print(os.getpid(), "结束")
#     return a * b
#
# if __name__ == "__main__":
#     tp = ProcessPoolExecutor(4)
#     futrue_list = []
#     for i in range(20):     # 异步非阻塞的
#         ret = tp.submit(func, i, b=i+1)
#         futrue_list.append(ret)
#     for obj in futrue_list:     # 同步阻塞的
#         print(obj.result())




# map  只适合传递简单参数，并且必须是一个可迭代的类型作为参数
# import os
# import time
# import random
# from threading import current_thread
# from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
#
# def func(a):
#     b = a + 1
#     print(os.getpid(), "开始", a, b)
#     time.sleep(random.randint(1, 4))
#     print(os.getpid(), "结束")
#     return a * b
#
# if __name__ == "__main__":
#     tp = ProcessPoolExecutor(4)
#     ret = tp.map(func, range(20))
#     for obj in ret:
#         print(obj)




# 回调函数
import os
import time
import random
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

def func(a ,b):
    print(current_thread().ident, "开始", a, b)
    time.sleep(random.randint(1, 4))
    print(current_thread().ident, "结束", a)
    return a * b

def print_func(ret):
    print(ret.result())

if __name__ == "__main__":
    tp = ThreadPoolExecutor(4)
    futrue_list = []
    for i in range(20):     # 异步非阻塞的
        ret = tp.submit(func, i, b=i+1)
        ret.add_done_callback(print_func)   #异步阻塞

# 异步阻塞  回调函数  给ret对象绑定一个回调函数，等待ret对应的任务有了结果之后立即调用print_func这个函数
# 就可以对结果立即进行处理，而不要按照顺序接受结果处理结果