池

池

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

# concurrent.futures模块 线程池,进程池都能够用相似的方式开启使用
from threading import current_thread
from concurrent.futures import  ThreadPoolExecutor,ProcessPoolExecutor
import time
import random
def func():
    print(current_thread().ident,'start')
    time.sleep(random.randint(1,4))
    print(current_thread().ident, '---->end')

tp = ThreadPoolExecutor(4)#实例化线程池
for i in range(100):
    tp.submit(func)#向池中提交任务
    
#传递参数
from threading import current_thread
from concurrent.futures import  ThreadPoolExecutor,ProcessPoolExecutor
import time
import random
def func(a,b):
    print(current_thread().ident,'start',a,b)
    time.sleep(random.randint(1,4))
    print(current_thread().ident, '---->end')

tp = ThreadPoolExecutor(4) #实例化线程池
for i in range(100):
    tp.submit(func,i,i+1)#向池中提交任务

# 进程池
import os
import time,random
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
    print(os.getpid(),'start',a,b)
    time.sleep(random.randint(1,4))
    print(os.getpid(),'end')

if __name__ == '__main__':
    tp = ProcessPoolExecutor(4)
    for i in range(20):
        tp.submit(func,i,b=i+1)

# 获取任务结果
import os
import time,random
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
    print(os.getpid(),'start',a,b)
    time.sleep(random.randint(1,4))
    print(os.getpid(),'end')
    return a*b

if __name__ == '__main__':
    tp = ProcessPoolExecutor(4)
    futrue_l = {}
    for i in range(20):         # 异步非阻塞的
        ret = tp.submit(func,i,b=i+1)
        futrue_l[i] = ret
        # print(ret.result())   # Future未来对象
    for key in futrue_l:       # 同步阻塞的
        print(key,futrue_l[key].result())

# map  只适合传递简单的参数,并且必须是一个可迭代的类型作为参数
import os
import time,random
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a):
    print(os.getpid(),'start',a[0],a[1])
    time.sleep(random.randint(1,4))
    print(os.getpid(),'end')
    return a[0]*a[1]

if __name__ == '__main__':
    tp = ProcessPoolExecutor(4)
    ret = tp.map(func,((i,i+1) for i in range(20)))
    for key in ret:       # 同步阻塞的
        print(key)

# 回调函数 : 效率最高的*****
import time,random
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor

def func(a,b):
    print(current_thread().ident,'start',a,b)
    time.sleep(random.randint(1,4))
    print(current_thread().ident,'end',a)
    return (a,a*b)

def print_func(ret):       # 异步阻塞
    print(ret.result())

if __name__ == '__main__':
    tp = ThreadPoolExecutor(4)
    futrue_l = {}
    for i in range(20):         # 异步非阻塞的
        ret = tp.submit(func,i,b=i+1)
        ret.add_done_callback(print_func)  
# ret这个任务会在执行完毕的瞬间立即触发print_func函数,并且把任务的返回值对象传递到print_func做参数
        # 异步阻塞 回调函数 给ret对象绑定一个回调函数,等待ret对应的任务有了结果之后立即调用print_func这个函数
        # 就可以对结果立即进行处理,而不用按照顺序接收结果处理结果