#進程池: 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(‘吃完了‘)#主代碼結束以後守護進程（消費者函數）也隨之結束。
#隊列內部自帶互斥鎖，不會出現幾個進程同時取一個數據的情況。維護先進先出的順序，保證了數據的安全。

py 6.13