py 6.13

Posted 2020-11-17 liujjpeipei

#进程池: 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(‘吃完了‘)#主代码结束以后守护进程（消费者函数）也随之结束。
#队列内部自带互斥锁，不会出现几个进程同时取一个数据的情况。维护先进先出的顺序，保证了数据的安全。

队列