python—day29 守护进程互斥锁模拟抢票IPC通信机制生产者消费者模型

Posted 2020-11-01 kermitjam

1、守护进程：

什么是守护进程，假如你是皇帝，每日每夜守护你的就是太监，守护进程就相当于太监，当皇帝驾崩后太监也需要陪葬，所以守护进程当父进程销毁时就一起销毁；

 

 1 from multiprocessing import Process
 2 
 3 import time
 4 
 5 def task(name):
 6 
 7     time.sleep(0.5)
 8     print(‘%s‘ %name)
 9 
10 
11 if __name__ == ‘__main__‘:
12     p = Process(target=task,args=(‘kermit‘,))
13     p.daemon = True
14     p.start()
15     print(‘=====>‘)

View Code

 

 

2、互斥锁：

强调：必须是lock.acquire()一次，然后lock.release()释放一次，才能继续lock.acquire()，不能连续lock.acquire()

互斥锁 vs join()的区别一：

大前提：二者的原理都是一样，都是将并发编程串行，从而保证有序；

区别：join是按照认为指定的顺序执行，而互斥锁是所有进程平等地竞争；

 1 from multiprocessing import Process,Lock
 2 import time,random
 3 
 4 mutex=Lock()
 5 
 6 def task1(lock):
 7     lock.acquire() #
 8     print(‘task1:名字是egon‘)
 9     time.sleep(random.randint(1,3))
10     print(‘task1:性别是male‘)
11     time.sleep(random.randint(1,3))
12     print(‘task1:年龄是18‘)
13     lock.release()
14 
15 def task2(lock):
16     lock.acquire()
17     print(‘task2:名字是alex‘)
18     time.sleep(random.randint(1,3))
19     print(‘task2:性别是male‘)
20     time.sleep(random.randint(1,3))
21     print(‘task2:年龄是78‘)
22     lock.release()
23 
24 
25 def task3(lock):
26     lock.acquire()
27     print(‘task3:名字是lxx‘)
28     time.sleep(random.randint(1,3))
29     print(‘task3:性别是female‘)
30     time.sleep(random.randint(1,3))
31     print(‘task3:年龄是30‘)
32     lock.release()
33 
34 
35 if __name__ == ‘__main__‘:
36     p1=Process(target=task1,args=(mutex,))
37     p2=Process(target=task2,args=(mutex,))
38     p3=Process(target=task3,args=(mutex,))
39 
40     # p1.start()
41     # p1.join()
42     # p2.start()
43     # p2.join()
44     # p3.start()
45     # p3.join()
46 
47     p1.start()
48     p2.start()
49     p3.start()

 

3、模拟抢票程序：

 

 1 import json
 2 import time
 3 import random
 4 import os
 5 from multiprocessing import Process,Lock
 6 mutex = Lock()
 7 
 8 def search():
 9     time.sleep(random.randint(1,3))
10     dic = json.load(open(‘db.json‘,‘r‘,encoding=‘utf-8‘))
11     print(‘%s 剩余票数：%s‘ %(os.getpid(),dic[‘count‘]))
12 
13 
14 def get():
15     time.sleep(random.randint(1,2))
16     dic = json.load(open(‘db.json‘,‘r‘,encoding=‘utf-8‘))
17     if dic[‘count‘]>0:
18         dic[‘count‘] -=1
19         with open(‘db.json‘,‘w‘,encoding=‘utf-8‘) as f:
20             json.dump(dic,f)
21             print(‘%s购票成功！‘ %os.getpid())
22 
23 def task(lock):
24     search()
25     lock.acquire()
26     get()
27     lock.release()
28 
29 
30 if __name__ == ‘__main__‘:
31     for i in range(10):
32         p = Process(target=task,args=(mutex,))
33         p.start()

 

 

 

4、IPC通信机制

进程之间通信必须找到一种介质，该介质必须满足

1、是所有进程共享的；

2、必须是内存空间的；

附加：帮我们自动处理好锁的问题

 

 1 # from multiprocessing import Process,Manager,Lock
 2 # import time
 3 #
 4 # mutex=Lock()
 5 #
 6 # def task(dic,lock):
 7 #     lock.acquire()
 8 #     temp=dic[‘num‘]
 9 #     time.sleep(0.1)
10 #     dic[‘num‘]=temp-1
11 #     lock.release()
12 #
13 # if __name__ == ‘__main__‘:
14 #     m=Manager()
15 #     dic=m.dict({‘num‘:10})
16 #
17 #     l=[]
18 #     for i in range(10):
19 #         p=Process(target=task,args=(dic,mutex))
20 #         l.append(p)
21 #         p.start()
22 #
23 #     for p in l:
24 #         p.join()
25 #     print(dic)

View Code

 

队列：

1、共享的空间；

2、是内存空间；

3、自动帮我们处理好锁的问题

from multiprocessing import Queue

 

1 q=Queue(3)
2 q.put(‘first‘)
3 q.put({‘second‘:None})
4 q.put(‘三‘)
5 
6 # q.put(4) #阻塞
7 print(q.get())
8 print(q.get())
9 print(q.get())

强调：

　1、队列用来存进程之间沟通的消息，数据量不应该过大

    2、maxsize的值超过的内存限制就变得毫无意义

 

5、生产者消费者模型：

该模型中包含两种重要的类：

1、生产者：将负责造数据的任务比喻成生产者；

2、消费者：接收生产者造出的数据来做进一步的处理，该类任务被比喻成消费者；

 

实现生产者消费者模型三要素

1、生产者

2、消费者

3、队列

 

什么时候用该模型：

程序中出现明显的两类任务，一类任务是负责生产，另一类任务负责处理生产的数据的

 

该模型的好处：

1、实现了生产者与消费者解耦和

2、平衡了生产力与消费力，即生产者可以一直不停地生产，消费者可以不停地处理，因为二者不再直接沟通，而是跟队列沟通；

 1 def counsumer(name,q):
 2     while True:
 3         res = q.get()
 4         time.sleep(random.randint(1,3))
 5         print(‘%s %s‘ %(name,res))
 6 
 7 def prodicer(name,q,food):
 8     for i in range(5):
 9         time.sleep(random.randint(1,2))
10         res = ‘%s%s‘ %(food,i)
11 
12 if __name__ == ‘__main__‘:
13     #1、共享的盆
14     q = Queue()
15 
16     #2、生产者们
17     p1 = Process(target=producer,args=(‘egon1‘,q,‘包子‘))
18     p2 = Process(target=producer,args=(‘egon2‘,q,‘泔水‘))
19     p3 = Process(target=producer,args=(‘egon3‘,q,‘米饭‘))
20 
21     #3、消费者们
22     c1 = Process(target=consumer,args=(‘alex1‘,q))
23     c2 = Process(target=consumer,args=(‘alex2‘,q))
24 
25     p1.start()
26     p2.start()
27     p3.start()
28     c1.start()
29     c2.start()