四. 并发编程 (进程锁概念使用)

一. 进程同步(multiprocess.Lock)

1. 多进程会出现抢占资源

通过刚刚的学习，我们千方百计实现了程序的异步，让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序，一旦开启也不受我们控制。
尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题：当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。

# 当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。
import os
import time
import random
from multiprocessing import Process

def work(n):
    print('%s: %s is running' %(n,os.getpid()))
    time.sleep(random.random())
    print('%s:%s is done' %(n,os.getpid()))

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

执行顺序比较紊乱
    0: 10128 is running
    1: 10248 is running
    2: 15396 is running
    1:10248 is done
    2:15396 is done
    0:10128 is done

2. 多进程使用锁来维护执行顺序(同步multiprocess.Lock)

 # 由并发变成了串行,牺牲了运行效率,但避免了竞争
import os
import time
import random
from multiprocessing import Process,Lock
def work(lock,n):
    lock.acquire()  拿钥匙进门
    print('%s: %s is running' % (n, os.getpid()))
    time.sleep(2)
    print('%s: %s is done' % (n, os.getpid()))
    lock.release()   还钥匙
if __name__ == '__main__':
    lock=Lock()       开启锁后数据就变成同步执行了   (意思就是 每一个进程都有个拿钥匙和还钥匙的过程)
    for i in range(3):
        p=Process(target=work,args=(lock,i))
        p.start()

# 执行有序
#     0: 5208 is running
#     0: 5208 is done
#     1: 3332 is running
#     1: 3332 is done
#     2: 2528 is running
#     2: 2528 is done

上面这种情况虽然使用加锁的形式实现了顺序的执行，但是程序又重新变成串行了，这样确实会浪费了时间，却保证了数据的安全。

多进程同时抢购余票
from multiprocessing import Process
from multiprocessing import Lock
import pickle,json,time
# 通过刚刚的学习，我们千方百计实现了程序的异步，让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序，
# 一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题。
# 当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。
def show(i):
    with open("aa")as f1:
        aa=json.load(f1)
        print("余票为%s显示%s"%(aa["lover"],i))

def buy(i):
    with open("aa")as f1:
      dic=json.load(f1)
      if dic["lover"]>0:
          dic["lover"]-=1
          print("我买到票%s"%i)
      else:
          print("我没有买到")

      time.sleep(2)
      with open("aa","w") as f2:
          json.dump(dic,f2)

if __name__=="__main__":
    for i in range(5):
       p1=Process(target=show,args=(i,))
       p1.start()
    for i in range(5):
        p1 = Process(target=buy,args=(i,))
        p1.start()

# 余票为1显示0
# 余票为1显示3
# 余票为1显示1
# 余票为1显示2
# 余票为1显示4
# 我买到票0
# 我买到票2
# 我买到票1
# 我买到票3
# 我买到票4


print("*************************************************")

使用锁来保证数据安全
from multiprocessing import Process
from multiprocessing import Lock
import pickle,json,time

def show(i):
    with open("aa")as f1:
        aa=json.load(f1)
        print("余票为%s"%(aa["lover"]))
def buy(i,look):
    look.acquire()    # 拿钥匙
    with open("aa")as f1:
      dic=json.load(f1)
      time.sleep(1)
      if dic["lover"]>0:
          dic["lover"]-=1
          print("我买到票%s"%i)
      else:
          print("我没有买到%s"%i)
      time.sleep(2)
      with open("aa","w") as f2:
          json.dump(dic,f2)
      look.release()       # 还钥匙
if __name__=="__main__":

    for i in range(5):
       p1=Process(target=show,args=(i,))
       p1.start()
    look=Lock()   # 开启锁     就变成同步的效果了   因为进来一个就要拿钥匙和还钥匙过程  不会造成数据紊乱
                   # 但是在之前还是异步

    for i in range(5):
        p1 = Process(target=buy,args=(i,look))
        p1.start()
# 余票为2
# 余票为2
# 余票为2
# 余票为2
# 余票为2
# 我买到票1
# 我买到票0
# 我没有买到2
# 我没有买到3
# 我没有买到4

#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的数据）
2.需要自己加锁处理

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