进程池和线程池对比

进程池是主程序结束就自动结束,map是自带close方法和join方法 (执行(进程或线程)结束才会继续向后执行)

线程池是主进程结束不影响线程池

进程池: 进程的创建和销毁是很有消耗的,影响代码执行效率

　　map:异步提交任务,并且传参需要可迭代类型的数据,自带close和join功能

　　测试多进程和进程池的效率对比:

import time
from multiprocessing import Process,Pool
 
def f1(m):
    for i in range(5):
        m += i
 
if __name__ == '__main__':
    # 进程池设置三个进程
    p1 = Pool(3)
    # 创建进程时得到时间戳
    p1_go_time = time.time()
    # 参数1放进程的逻辑,参数2放可迭代对象.map是异步提交任务,但自带close和join
    p1.map(f1,range(100))
    # 所有进程结束后得到一个时间戳
    p1_end_time = time.time()
    p1_time = p1_end_time - p1_go_time
 
    p2_lis = []
    # 创建进程时得到时间戳
    p2_go_time = time.time()
    for i in range(100):
        # 创建进程对象,把循环的内容当做参数,传给函数
        p2 = Process(target=f1,args=(i,))
        p2.start()
        # 把进程对象都添加到列表中,方便让对象都join.
        p2_lis.append(p2)
 
    for i in p2_lis:
        #把每个创建的进程对象都join,进程最慢的执行完之后,继续向下执行
        #假如不加join的话,就是for循环创建完所有进程之后,直接向后执行,而子进程并没有执行完.
        i.join() 
    # 所有多进程结束后得到一个时间戳
    p2_end_time = time.time()
    p2_time = p2_end_time - p2_go_time
 
    print("进程池耗时:",p1_time)
    print("多进程耗时:", p2_time)

　　res = apply( f1,args=(i,) ) #同步执行任务,必须等任务执行结束才能给进程池提交下一个任务,可以直接拿到返回结果res

import time
from multiprocessing import Process,Pool
 
def f1(n):
    time.sleep(1)
    # print(n)
    return n*n
 
if __name__ == '__main__':
    pool = Pool(4)
 
    for i in range(10):
        print('xxxxxx')
        res = pool.apply(f1,args=(i,))
        print(res)

　　res_obj = apply_async( f1,args=(i,) ) #异步提交任务,可以直接拿到结果对象,从结果对象里面拿结果,要用get方法,get方法会阻塞程序,没有拿到结果会一直等待.

　　close : 锁住进程池,防止有其他的新的任务在提交给进程池

　　join : 等待着进程池将自己里面的任务都执行完

　　get : 拿到函数执行的结果

import time
from multiprocessing import Process, Pool


def f1(n):
    time.sleep(2)
    print(n)
    return n * n


if __name__ == '__main__':
    pool = Pool(4)

    res_list = []
    for i in range(10):
        print('xxxx')
        # 异步给进程池提交任务
        res = pool.apply_async(f1, args=(i,))
        res_list.append(res)

    print('等待所有进程执行完')
    pool.close()  #锁住进程池,意思就是不让其他的程序再往这个进程池里面提交任务了
    pool.join()   #等进程执行完之后,才继续向下执行
    print('所有进程执行结束')

    time.sleep(2)
    # 打印结果,如果异步提交之后的结果对象
    for i in res_list:
        print(i.get())

    print("主程序结束")

线程池:

　　from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

　　t = ThreadPoolExecutor(4) #默认的线程个数是cpu个数 * 5

　　p = ProcessPoolExecutor(4) #默认的进程个数是cpu个数

　　t.map(f1,可迭代的对象) #异步执行

import  time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
 
def f1(n):
    time.sleep(1)
    print(n)
 
if __name__ == '__main__':
    t = ThreadPoolExecutor(5)
    t.map(f1,range(10))
    t.shutdown()
 
    print('主程序结束')

　　def f1(n1,n2):

　　　　print(n1,n2)

　　t.submit(f1,11,12) # 异步提交任务 ,第一个参数是函数,后面是无敌传参,看函数需要几个参数

　　res = t.submit(f1,11,12)

　　res.result() # 和进程池的get方法一样,如果没有结果,会等待,阻塞程序

　 shutdown() # close+join,锁定线程池,等待线程池中所有已经提交的任务全部执行完毕

import  time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
 
def f1(n,m):
    time.sleep(1)
    print(n)
    return n+m
 
if __name__ == '__main__':
    t = ThreadPoolExecutor(5)
    t_lis = []
    for i in range(10):
        ret = t.submit(f1,i,5)
        t_lis.append(ret)
    t.shutdown()
    for i in t_lis:
        print(i.result())
 
    print('主程序结束')

进程池和线程池对比

猜你喜欢