40.多进程同步--锁--多把锁

多进程同步 

---

• 首先多进程默认是并发行为，多个进程同时执行
• 执行的顺序，以及何时执行完毕无法控制
  • 多个进程如果涉及到了通信，数据的有序性无法保证
  • 需要锁来控制进程之间执行的顺序
  • 对于进程资源的控制
• 缺点：同步进程，并发没有了。效率低下。
• Lock：一把锁
• Lock.acquire() 拿着锁 通信证
  • 抢占锁，如果拿不到，阻塞等待
• Lock.release() 放掉锁
  • 一定要记得在工作完毕之后释放锁。
• **Semaphore**：多把锁，同时提供多把锁/通行证，保证可以有一定个数的进程保持并发，这个用的多一点
  • s = Semaphore(3)
  • s.acquire()
  • s.release()
• 一般情况下我们多进程操作数据库的时候必须加锁，这样才能保证数据的有序性

• #多进程同步/锁
  from multiprocessing import Process,current_process,Lock
  import sys 
  from time import sleep
  def work(l):
          print('%s进程已经开始了' % current_process().name)
          l.acquire() #抢占这个通信证/锁
          for var in range(65,68):
                  print('%s:%s' % (current_process().name,chr(var)))
                  sys.stdout.flush()
          l.release() #放掉通行证
  def main():
          l = Lock()
          Process(target=work,name='a',args=(l,)).start()
          Process(target=work,name='b',args=(l,)).start()
          Process(target=work,name='c',args=(l,)).start()
  if __name__ == "__main__":
          main()
  

  运行结果：

  a进程已经开始了               y
  a:A
  a:B
  a:C
  b进程已经开始了
  b:A
  b:B
  b:C
  c进程已经开始了
  c:A
  c:B
  c:C
  

• #多进程同步/多把锁（信号量）
  from multiprocessing import Process,current_process,Semaphore
  import sys 
  from time import sleep
  def work(s):
          print('%s进程已经开始了' % current_process().name)
          s.acquire()
          for var in range(65,100):
                  print('%s:%s' % (current_process().name,chr(var)))
                  sys.stdout.flush()
          s.release()
  def main():
          s = Semaphore(3) #通行证，限制同一时间提供了3把锁，也就是说同一时间最多3个进程同时工作，其余的进程阻塞等待，
          Process(target=work,name='a',args=(s,)).start()
          Process(target=work,name='b',args=(s,)).start()
          Process(target=work,name='c',args=(s,)).start()
          Process(target=work,name='d',args=(s,)).start()
          Process(target=work,name='e',args=(s,)).start()
  if __name__ == "__main__":
          main()