# 管道

from multiprocessing import Pipe,Process

def func(conn1,conn2):
    conn2.close()   #子進程只關閉conn2時會拋出一個EOFError（沒數據可取時recv)，根據EOFError結束循環
    while True:
        try :
            msg = conn1.recv()#不判斷話會阻塞
            print(msg)
        except EOFError:
            conn1.close()
            break
 

if __name__ == ‘__main__‘:
    conn1, conn2 = Pipe()
    Process(target=func,args = (conn1,conn2)).start()
    conn1.close()
    for i in range(20):
        conn2.send(‘吃了麽‘)
    conn2.close()  #主進程Conn1和Conn2全部關閉，不會影響子進程的Conn1和Conn2

管道實現生產者消費者模型

# from multiprocessing import Lock,Pipe,Process
 
# def producer(con,pro,name,food):
#     con.close()
#     for i in range(100):
#         f = ‘%s生產%s%s‘%(name,food,i)
#         print(f)
#         pro.send(f)
#     pro.send(None)
#     pro.send(None)
#     pro.send(None)
#     pro.close()
#
# def consumer(con,pro,name,lock):
#     pro.close()
#     while True:
#             lock.acquire()
 
#             food = con.recv()
#             lock.release()
#             if food is None:
#                 con.close()
#                 break
#             print(‘%s吃了%s‘ % (name, food))
# if __name__ == ‘__main__‘:
#     con,pro = Pipe()
#     lock= Lock()
#     p = Process(target=producer,args=(con,pro,‘egon‘,‘泔水‘))
#     c1 = Process(target=consumer, args=(con, pro, ‘alex‘,lock))
#     c2 = Process(target=consumer, args=(con, pro, ‘bossjin‘,lock))
#     c3 = Process(target=consumer, args=(con, pro, ‘wusir‘,lock))
#     c1.start()
#     c2.start()
#     c3.start()
#     p.start()
#     con.close()
#     pro.close()

# from multiprocessing import Process,Pipe,Lock
#
# def consumer(produce, consume,name,lock):
#     produce.close()
#     while True:
#         lock.acquire()
#         baozi=consume.recv()
#         lock.release()
#         if baozi:
#             print(‘%s 收到包子:%s‘ %(name,baozi))
#         else:
#             consume.close()
#             break
#
# def producer(produce, consume,n):
#     consume.close()
#     for i in range(n):
#         produce.send(i)
#     produce.send(None)
#     produce.send(None)
#     produce.close()
#
# if __name__ == ‘__main__‘:
#     produce,consume=Pipe()
#     lock = Lock()
#     c1=Process(target=consumer,args=(produce,consume,‘c1‘,lock))
#     c2=Process(target=consumer,args=(produce,consume,‘c2‘,lock))
#     p1=Process(target=producer,args=(produce,consume,30))
#     c1.start()
#     c2.start()
#     p1.start()
#     produce.close()
#     consume.close()

# pipe 數據不安全性
# IPC
# 加鎖來控制操作管道的行為 來避免（多人消費同時取一個數據）進程之間爭搶數據造成的數據不安全現象

# 隊列 進程之間數據安全的
# 管道 + 鎖


#  進程之間的數據共享

普通正常的進程之間數據是不共享的
# from multiprocessing import Manager,Process

# def main(dic):
#     dic[‘count‘] -= 1
#     print(dic)
#
# if __name__ == ‘__main__‘:
#     m = Manager()
#     dic=m.dict({‘count‘:100})
#     p_lst = []
#     p = Process(target=main, args=(dic,))
#     p.start()
#     p.join()

from multiprocessing import Manager,Process,Lock
def main(dic,lock):
    lock.acquire()
    dic[‘count‘] -= 1  #這裏會出現兩個進程同時修改一個數據情況，最後會發現每次次執行count的值不一樣，就是因為多進程同時操作一個數據導致的
   lock.release()     #，正常理想count值應該是50，為了達到這效果就加鎖。雖然加鎖在效率會降低，但安全

if __name__ == ‘__main__‘:
    m = Manager()
    l = Lock()
    dic=m.dict({‘count‘:100})
    p_lst = []
    for i in range(50):
        p = Process(target=main,args=(dic,l))
        p.start()
        p_lst.append(p)
    for i in p_lst: i.join()
    print(‘主進程‘,dic)

#  進程池1

進程---管道、數據共享Manager、進程池和回調函數（重要）（六）