进程锁|,守护进程,IPC,生产者消费者模型

1.进程通信 Inter Process Communication

可以通过文件通信 ,基于scoket通信 ,队列Queue

2.锁 : 解决在大量进程并发时数据不安全问题.买票的例子

import time
import json
from multiprocessing import Process
from  multiprocessing import Lock

def search(i):
    with open('ticket',encoding='utf-8')as f:
        ticket = json.load(f)
        print('第%s个人查到当前剩余票数%s'%(i,ticket['ticket']))
    return ticket['ticket']

def buy_tic(i,lock):
    ticket = search(i)
    if ticket >0:
        lock.acquire()
        print('%s买到了票'%i)
        ticket = ticket -1
        with open('ticket',mode='w',encoding='utf-8')as f:
            json.dump({'ticket':ticket},f)
        lock.release()



if __name__ == '__main__':
    lock = Lock()
    for i in range(10):
        p = Process(target=buy_tic,args=(i,lock))
        p.start()

3.队列 Queue put方法 放数据 ,get()拿数据, get方法会引起阻塞

from multiprocessing import Process,Queue
import time,random
def consumer(q):
    for i in range(10):
     print(q.get())

def producer(q):
    for i  in range(10):
        q.put(i)
        time.sleep(random.random())

if __name__ == '__main__':
    q =Queue()
    P1 =Process(target=producer,args=(q,))
    P2 =Process(target=consumer,args=(q,))
    P1.start()
    P2.start()

4.生产者消费者模型 :让生产数据 和 取数据达到平衡,最大化效率,需要一个容器存数据可以是队列

from multiprocessing import Process,Queue

def consumer(name,q):

    while True:
        food = q.get()
        if food:
            print('%s吃了%s'%(name,food))
        else:break

def producter(name,food,q):
    for i in range(10):
        foodi = '%s%s'%(food,i)
        q.put(foodi)
        print('%s产出了%s'%(name,foodi))


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producter,args=('dong','香蕉',q))
    p2 = Process(target=producter,args=('name','苹果',q))
    p3 = Process(target=consumer,args=('ting',q))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    q.put(None)

 5.Manager ,可以实现进程中数据共享,但是速度很慢,利用了锁,如果真的想共享数据,最好不要用

多进程

from multiprocessing import Manager,Process,Lock

def change_dic(lock,dic):
    with lock:
        dic['count'] -= 1


if __name__ == '__main__':
   with Manager() as m:
    lock =Lock()
    # m = Manager()
    dic = m.dict({'count':100})
    p_l =[]
    for i in range(10):
        p = Process(target=change_dic,args=(lock,dic))
        p_l.append(p)
        p.start()
    for p in p_l:
        p.join()
    print(dic)

6.守护进程: 一般程序会在所有子进程结束后结束,要回收子进程资源

如果是守护今程就会在程序代码结束前结束进程

from multiprocessing import Process
import time
def son1():
    while 1:
        print('in son1')
        time.sleep(1)
def son2():
    for i in range(10):
        print('in son2')
        time.sleep(1)
if __name__ == '__main__':
    p = Process(target=son1)
     #p是守护进程,会在程序代码结束后结束
    #in son1 和iin son2 只会运行三次结束
    p.daemon =True
    p.start()
    p1 = Process(target=son2)
    p1.daemon =True
    p1.start()
    time.sleep(3)