四. 並發編程 (進程鎖概念使用)

一. 進程同步(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通信機制：隊列和管道。
隊列和管道都是將數據存放於內存中
隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來，
我們應該盡量避免使用共享數據，盡可能使用消息傳遞和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性。