进程互斥（锁）------------------>一个坑

进程互斥锁

引入：

　　进程之间数据不共享,但是共享同一套文件系统（如硬盘、键盘、cpu等）,所以访问同一个文件,或同一个打印终端,是没有问题的,竞争带来的结果就是错乱，如何控制，就是加锁处理，即进程加锁。

 #并发运行,效率高,但竞争同一打印终端,带来了打印错乱
 from multiprocessing import Process
 import os,time
 def work():
     print('%s is running' %os.getpid())
     time.sleep(2)
     print('%s is done' %os.getpid())

 if __name__ == '__main__':
     for i in range(3):
         p=Process(target=work)
         p.start()

 # 并发运行,效率高,但竞争同一打印终端,带来了打印错乱

特点：

　　1.某进程先获取到cpu资源之后，要立即上锁，避免其他人对资源的竞争，只有当该进程解锁（释放）之后，剩余的进程才能进行竞争。

　　2.进程互斥锁使得程序的执行顺序成为串行，牺牲了效率，但提高了安全性。

　　3.同一时刻只允许一个进程运行，其他进程只能等待。（这与后面的信号量相反，信号量允许多个进程同时运行）

代码示例：

 from multiprocessing import Process,Lock
 import os,time
 def work(lock):
     lock.acquire() #上锁
     print('%s is running' %os.getpid())
     time.sleep(2)
     print('%s is done' %os.getpid())
     lock.release()#解锁
 if __name__ == '__main__':
     lock = Lock()#创建一个互斥锁对象
     for i in range(3):
         p=Process(target=work,args=(lock,))
         p.start()

进程互斥锁

互斥锁解决抢票问题：

 from  multiprocessing import Process,Lock
 import json
 import os
 import time
 import random

 def search():
     with open('db.txt',encoding='utf-8') as f:#在当前目录创建一个db.txt文件，并写入“ {"count":1} ”
         dic=json.load(f)
         print('%s 剩余票数 %s' %(os.getpid(),dic['count']))

 def get():
     with open('db.txt',encoding='utf-8') as read_f:
         dic=json.load(read_f)

     if dic['count'] > 0:
         dic['count']-=1
         time.sleep(random.randint(1,3)) #模拟手速+网速
         with open('db.txt','w',encoding='utf-8') as write_f:
             json.dump(dic,write_f)
             print('%s 抢票成功' %os.getpid())

 def task(mutex):
     search()
     mutex.acquire()
     get()
     mutex.release()

 if __name__ == '__main__':
     mutex=Lock()
     for i in range(20):
         p=Process(target=task,args=(mutex,))
         p.start()
         p.join()

总结：

　　加锁可以保证多个进程修改同一块数据，但是同一时刻只允许一个进程对其修改，其他进程必须等待，即穿行修改，牺牲了效率，但保证了数据的安全性，但如果加锁的步骤增多，又会造成程序的复杂性。

扩展：

　　因此我们最好找寻一种解决方案能够兼顾：1、效率高（多个进程共享一块内存的数据）2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。队列和管道都是将数据存放于内存中队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。