#进程池: Pool : 节省系统回收资源的时间，降低操作系统的难度。
#适合纯计算型的程序。 多进程：适合高IO
# from multiprocessing import Pool
#
# def cal(num):
# print(num*num)
# return num*'-' #返回给apply_async提交任务端r。用get获取返回值。
#
# if __name__ == '__main__':
# p = Pool(5) #进程池的进程数根据：CPU/CPU+1
# lis =[]
# for i in range(101):
# r = p.apply_async(func=cal,args=(i,))(func=函数名，args=参数)#异步操作，提交一个任务。
# lis.append(r) #如果每次都get的话，就变成同步操作了。
# for r_lis in lis:
# print(r_lis.get())
# p.close() #与jojn必须同时存在。关闭进程池(里面进程不会结束)防止进一步操作，不再接收新的任务。
# p.join() #等待所有子进程结束后再结束主代码，否则主进程会直接结束。必须放在close后面。
#p.apply:同步提交任务，失去了多进程的作用。
#p.map: 与p.apply_async功能一样，省略了close和join,但是没有返回值。
# from multiprocessing import Pool
#
# def cal(num):
# print(num*num)
#
# if __name__ == '__main__':
# p = Pool(5)
# p.map(func=cal,iterable =range(101)) #(func= 函数名，iterable = 可迭代对象)
#不需要关闭和阻塞。
#进城池中的回调函数
# import os
# from multiprocessing import Pool
#
# def wahaha():
# return 5
#
# def call(argv):#接收一个参数，接收的是wahaha的返回值。
# print(os.getpid())#跟主进程的pid相同，利用的是主进程的资源。原因：在子进程工作且主进程
# print(argv) #空闲时，利用主进程来进程一些简单的运算分析。
#
# if __name__ == '__main__':
# print(os.getpid())
# p = Pool(5)
# p.apply_async(func=wahaha,callback=call)#call:回调函数名 . 接收wahaha中的返回值。
# p.close()
# p.join()
进程池
#Pipe:管道。lr,lp = Pipe() 管道的两端有一端不用的时候都需要关闭。
#管道的数据不安全。队列的实现机制：管道+锁。
# from multiprocessing import Process,Pipe
#
# def func(lr,rp):
# lr.close() #将不用的发送端关闭，管道中依据引用计数，必须关闭所有管道才能生成EOFError异常。
# while True:
# try:
# print(rp.recv())
# except EOFError:break
#
# if __name__ == '__main__':
# lr ,rp = Pipe() #创建管道的两端
# Process(target=func,args=(lr,rp)).start()#可开启多个子进程
# lr.send('hello') #一端发送。
# rp.close() #将不用的接收端关闭
# lr.close() #发送完毕后将发送端关闭，使子进程报错，进入异常处理
#进程间可以数据共享，如列表字典，但是会造成数据混乱。、
管道
# import time
# import random
# from multiprocessing import Process,Queue
#
# def consumer(q):
# while True:
# obj = q.get()
# if obj == None:break
# print('消费了一个数据%s'%obj)
# time.sleep(random.randint(1,3))
#
# def produser(q):
# for i in range(10):
# time.sleep(random.randint(1,5))
# q.put('food%s'%i)
# print('生产了一个food%s'%i)
#
# if __name__ == '__main__':
# q = Queue()
# p = Process(target=consumer,args=(q,))
# p.start()
#tcp协议实现与多客户端通信。1.socketserver 2:创建多个进程与client通信。
#队列。生产消费模型：
# import time
# import random
# from multiprocessing import Process,Queue
#
# def consumer(name,q):
# while True:
# obj = q.get() #如果队列中无值可取，则阻塞，等待放值再取值。
# if obj == None:break #主中等待生产函数完成时，往队列里放了与消费者数等同的None.
# print('%s拿出了一个数据%s'%(name,obj))
# time.sleep(random.randint(1,3))
#
# def produser(name,q):
# for i in range(10):
# time.sleep(random.randint(1,5))
# q.put('food%s'%i) #循环一次放入一个，可以有多个生产者一起异步生产。
# print('%s放入了一个数据food%s'%(name,i))
#
# if __name__ == '__main__':
# q = Queue()
# # p1 = Process(target=consumer,args=('alex',q))
# p2 = Process(target=consumer,args=('egon',q)) #创建多个消费者，将姓名与队列对象传进去。
# p3 = Process(target=produser,args=('zhangsan',q))#创建多个生产者
# p4 = Process(target=produser,args=('lisi',q))
# lis = [p2,p3,p4] #由于创建进程较多，可以循环开启。
# for p in lis:
# p.start()
# p3.join() #为使消费者get不阻塞，需要放入一个标志位使消费者知道已经生产完成了，所以将生成函数阻塞，等到所有生产
# p4.join() #函数结束时，执行下面加None标志位的代码。
# q.put(None) #有几个消费者就加几个，否则有的取不到就会等待。程序无法结束。
# q.put(None)
#JoinableQueue:不用加标志位告知，通过感知task_done执行是否完成来判断队列是否为空，生产是否完成。、
# import time
# import random
# from multiprocessing import Process,JoinableQueue
#
# def consumer(name,q):
# while True:
# obj = q.get() #不能根据get判断是否取完，因为get到数据后需要处理，不能马上结束。
# if obj == None:break
# print('%s吃了%s'%(name,obj))
# time.sleep(random.randint(1,3))
# q.task_done() #告知队列已经取了一次数据。如果一共10个数据，则取10次。
#
# def produser(name,q):
# for i in range(10):
# time.sleep(random.randint(1,5))
# q.put('第%s坨屎'%i)
# print('%s拉了第%s坨屎'%(name,i))
#
# if __name__ == '__main__':
# q = JoinableQueue()
# p1 = Process(target=consumer,args=('吕杨',q))
# p1.daemon = True #将消费者进程设为守护进程。
# p2 = Process(target=consumer,args=('李淑旗',q))
# p2.daemon = True
# p3 = Process(target=produser,args=('la',q))
# p4 = Process(target=produser,args=('lala',q))
# lis = [p1,p2,p3,p4]
# for p in lis:
# p.start()
# p3.join()
# p4.join()
# q.join() #阻塞队列。判断task_done执行次数是否完成。执行完以后则解除阻塞，代码往下执行。
# print('吃完了')#主代码结束以后守护进程（消费者函数）也随之结束。
#队列内部自带互斥锁，不会出现几个进程同时取一个数据的情况。维护先进先出的顺序，保证了数据的安全。