线程进程 五 进程池

进程池

• 方便创建，管理进程，单独进程的Process创建，需要手动开启，维护任务函数，以及释放回收
• 进程池不需要这么麻烦，进程提前创建好，未来在使用的时候，可以直接给与任务函数
• 某个进程池中的任务结束了，占用的进程会自己释放刚才工作的事情，以便接收下一个

Process(target=,args=,).start() join()

P = Pool(num) #创建一个包含有num个空闲进程的池子
p.apply() 填充任务，任务如果结束，会自动释放掉当前占用的进程
创建大规模任务，Pool(100)

from mutliprocessing import Pool

• 创建进程池：进程池中的进程是可以复用

  • p = Pool(num)

    • num：指明当前多少空闲进程创建出来

  • p.apply(func,args,)

  • Process(target,args)，Lock()

    • 阻塞行为
    • func：指明填充功能函数名
    • args：对应的参数

  • p.apply_async(func,args,)

    • 非阻塞行为，

  • **p.close() **

    • 在整个业务结束之后，进程池要首先关闭
    • 没有办法填充新的任务

  • p.join()

    • 进程回收，把关闭了的进程池中的每个进程join() 释放回收掉

  • p.terminate()

    • 直接关闭进程池，并且终止所欲偶进程

• 进程池的工作的返回值：

  • res = p.apply(func,)
    • res就是进程池的工作结果
    • 立竿见影就可以看到结果，就因为apply填充任务是阻塞行为
  • res = p.apply_aysnc(func)
    • 非阻塞的结果，可以立即拿到，但是不是结果，只是一个抽象虚拟的值
      • 这个值代表进程结束后的返回值
    • res.get()
      • 当前非阻塞执行的进程，有优先级先结束
      • 强制要求立即这个结果，但是会影响进程之间的并发效果

• Pipe() 进程池通信没有管道

• Queue()

  • 进程池中的通信队列是特殊的

  • from multiprocessing import Manager

    array：共享内存，char short int long long unsizned# 周日上课：8点-9点半

实例 进程池数据通信

from multiprocessing import Pool,Manager,Queue
from time import sleep
import sys
import os
#pid,ppid = os.fork() #内核函数 
#if ppid == 0: 子进程
#if pid > 0: 父进程
def work_a(q):
	#生产者 放十次
	for var in range(10):
		print('生产者:',var) 
		sys.stdout.flush()
		q.put(var)
		sleep(1)
def work_b(q):
	#消费者，拿十次
	for var in range(10):
		res = q.get() #阻塞行为
		print('消费者:',var)
		sys.stdout.flush()
	#CPU 过来处理报错 终止进程，抛出错误
def main():
	q = Manager().Queue() #进程共享队列
	p = Pool(5) #进程可以复用
	p.apply_async(func=work_a,args=(q,))
	p.apply_async(func=work_b,args=(q,))
	p.close()
	p.join()
if __name__ == '__main__':
	main()

实例 进程池的工作结果如何获取

from multiprocessing import Pool
import sys
def work_a():
	for var in range(1,2000):
		print(var) 
		sys.stdout.flush()
	return 'a'
def work_b():
	for var in range(2000,4000):
		print(var)
		sys.stdout.flush()
	return 'b'
def work_c():
	for var in range(4000,6000):
		print(var)
		sys.stdout.flush()
	return 'c'
def main():
	p = Pool(4) #参数：可以最多同时执行任务个数，并不是填充的最大任务个数
	a = p.apply_async(func=work_a) 
	b = p.apply_async(func=work_b)
	c = p.apply_async(func=work_c)
	print('a进程:%s' % a.get()) #生成器
	print('b进程:%s' % b)
	print('c进程:%s' % c)
	p.close() #先关闭进程池，不代表进程池中的任务要停止
		#关闭了之后打不开了
	p.join()
if __name__ == '__main__':
	main()

实例 进程池

from multiprocessing import Pool
import sys
def work_a():
	for var in range(1,2000):
		print(var) 
		sys.stdout.flush()
def work_b():
	for var in range(2000,4000):
		print(var)
		sys.stdout.flush()
def work_c():
	for var in range(4000,6000):
		print(var)
		sys.stdout.flush()
def main():
	p = Pool(2) #参数：可以最多同时执行任务个数，并不是填充的最大任务个数
	#p.apply(func=work,args=(a,b),)
	p.apply_async(func=work_a)
	p.apply_async(func=work_b)
	p.apply_async(func=work_c)
	#?: 是否是阻塞行为执行完这三个任务
		#阻塞的话：1个等一个，同步
		#非阻塞：异步
	p.close()
	p.join()
if __name__ == '__main__':
	main()