45_并发编程-进程池

 1 <1> map()  - 并且自带close和join，一般约定俗成的是进程池中的进程数量为CPU的数量，工作中要看具体情况来考量。
 2 
 3 # 进程池与进程的时间比较
 4 
 5 import time
 6 from multiprocessing import Process, Pool
 7 
 8 def func(n):
 9     print(n)
10 
11 if __name__ == ‘__main__‘:
12 
13     # 进程池运行时间
14     time_pool_start = time.time()
15     pool =Pool(4)   # 进程池中只放4个进程
16     pool.map(func, range(100))      # 使用map方法实现,map实现的是异步的。map参数可迭代 range(100)，把可迭代的元素放入func中执行
17     time_pool_end = time.time()
18     p_dif = time_pool_end - time_pool_start
19 
20     # 进程运行时间
21     time_pro_start = time.time()
22     lst = []
23     for i in range(100):
24         p = Process(target=func, args=(i,))
25         p.start()
26         lst.append(p)
27     [obj.join() for obj in lst]
28     time_pro_end = time.time()
29     p_dif_pro = time_pro_end - time_pro_start
30 
31     print("进程池>>",p_dif)
32     print("进程>>", p_dif_pro)

 1 <2> apply()       -        apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。同步执行，一个一个出,它会等待任务的执行结果
 2                    需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用
 3 
 4 import time
 5 from multiprocessing import Process,Pool
 6 
 7 def fun(i):
 8     time.sleep(0.5)
 9     # print(i)
10     return i**2
11 
12 if __name__ == ‘__main__‘:
13     p = Pool(4)
14     for i in range(10):
15         res = p.apply(fun,args=(i,))  #同步执行的方法,他会等待你的任务的返回结果,
16         print(res)

 1 <3> apply_async()    -   apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果; 异步的
 2                         此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。
 3 
 4 import time
 5 from multiprocessing import Pool
 6 
 7 def func(n):
 8     time.sleep(0.5)
 9     return n**2
10 
11 if __name__ == ‘__main__‘:
12 
13     p = Pool(4)
14     lst = []    # 设置一个空列表
15     for i in range(10):
16         ret = p.apply_async(func, args=(i,))  # 异步步执行,获取返回值
17         lst.append(ret)     # 异步的,返回值放一个列表
18     time.sleep(1)
19     for el in lst:  # 循环列表
20         print(el.get()) # 获取异步结果,因为get()一次只能取一个值,使用进程池取数据，每4个一组一打
21 
22 ----------------------------------------------------------------------------------------
23 import time
24 from multiprocessing import Pool
25 
26 def func(n):
27     time.sleep(0.5)
28     print(n)
29     return n**2
30 
31 if __name__ == ‘__main__‘:
32 
33     p = Pool(4)
34     lst = []    # 设置一个空列表
35     for i in range(10):
36         ret = p.apply_async(func, args=(i,))  # 异步步执行,获取返回值,4个一组
37         lst.append(ret)     # 异步的每4个放一个列表
38 
39     p.close() # 不是关闭进程池,而是不允许再有其他任务来使用进程池
40     p.join()    # 这是感知进程池中任务的方法,等待进程池的任务全部执行完
41 
42     for el in lst:  # 循环列表,这样把进程池关上,不允许别的任务用，就会全部打印出来
43         print(el.get()) # 获取异步结果,因为get()一次只能取一个值
44     print(‘主进程‘)