互斥锁

 互斥锁 （Lock）

并发变成串行，效率降低了，保证数据不会错乱。

进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争，竞争带来的结果就是错乱，如下

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


def task(name):
    print("%s 1" % name)
    time.sleep(1)
    print("%s 2" % name)
    time.sleep(1)
    print("%s 3" % name)


if __name__ == "__main__":
    for i in range(3):
        p = Process(target=task, args=("进程%s" % i, ))
        p.start()

如何控制，就是加锁处理。而互斥锁的意思就是互相排斥。如果把多个进程比喻为多个人，互斥锁的工作原理就是多个人都要去争抢同一个资源：卫生间，一个人抢到卫生间后上一把锁，其他人都要等着，等到这个完成任务后释放锁，其他人才有可能有一个抢到......

互斥锁的原理：把并发改成串行，降低了效率，但保证了数据安全不错乱

# 由并发变成了串行,牺牲了运行效率,但避免了竞争
from multiprocessing import Process, Lock
import time


def task(name, mutex):
    mutex.acquire()      # 加锁
    print("%s 1" % name)
    time.sleep(1)
    print("%s 2" % name)
    time.sleep(1)
    print("%s 3" % name)
    mutex.release()    # 释放锁


if __name__ == "__main__":
    mutex = Lock()
    for i in range(3):
        p = Process(target=task, args=("进程%s" % i, mutex))
        p.start()

---

模拟抢票练习

多个进程共享同一文件，我们可以把文件当数据库，用多个进程模拟多个人执行抢票任务

#文件db.txt的内容为：{"count":1}
#注意一定要用双引号，不然json无法识别

from multiprocessing import Process
import json
import time


def search(name):
    time.sleep(1)   # 模拟网络延迟
    dic = json.load(open("db.txt", 'r', encoding="utf-8"))
    print("<%s> 查看到剩余票数[%s]" % (name, dic["count"]))


def get(name):
    time.sleep(1)    # 模拟网络延迟
    dic = json.load(open("db.txt", 'r', encoding="utf-8"))
    if dic["count"] > 0:
        dic["count"] -= 1
        time.sleep(2)    # 模拟网络延迟(支付，传数据)
        json.dump(dic,open("db.txt", 'w', encoding="utf-8"))
        print("<%s> 购票成功" % name)


def task(name):
    search(name)
    get(name)


if __name__ == "__main__":
    for i in range(10):
        p = Process(target=task, args=("路人%s" % i, ))
        p.start()

并发运行，效率高，但竞争写同一文件，数据写入错乱,只有一张票，卖成功给了10个人

<路人0> 查看到剩余票数[1]
<路人1> 查看到剩余票数[1]
<路人2> 查看到剩余票数[1]
<路人3> 查看到剩余票数[1]
<路人4> 查看到剩余票数[1]
<路人5> 查看到剩余票数[1]
<路人6> 查看到剩余票数[1]
<路人7> 查看到剩余票数[1]
<路人8> 查看到剩余票数[1]
<路人9> 查看到剩余票数[1]
<路人0> 购票成功
<路人1> 购票成功
<路人2> 购票成功
<路人3> 购票成功
<路人4> 购票成功
<路人5> 购票成功
<路人6> 购票成功
<路人7> 购票成功
<路人8> 购票成功
<路人9> 购票成功

加锁处理：购票行为由并发变成了串行，牺牲了运行效率，但保证了数据安全

#把文件db.txt的内容重置为：{"count":1}

from multiprocessing import Process, Lock
import json
import time


def search(name):
    time.sleep(1)   # 模拟网络延迟
    dic = json.load(open("db.txt", 'r', encoding="utf-8"))
    print("<%s> 查看到剩余票数[%s]" % (name, dic["count"]))


def get(name):
    time.sleep(1)    # 模拟网络延迟
    dic = json.load(open("db.txt", 'r', encoding="utf-8"))
    if dic["count"] > 0:
        dic["count"] -= 1
        time.sleep(2)    # 模拟网络延迟(支付，传数据)
        json.dump(dic,open("db.txt", 'w', encoding="utf-8"))
        print("<%s> 购票成功" % name)


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


if __name__ == "__main__":
    mutex = Lock()
    for i in range(10):
        p = Process(target=task, args=("路人%s" % i, mutex))
        p.start()

执行结果

<路人0> 查看到剩余票数[1]
<路人1> 查看到剩余票数[1]
<路人2> 查看到剩余票数[1]
<路人3> 查看到剩余票数[1]
<路人4> 查看到剩余票数[1]
<路人5> 查看到剩余票数[1]
<路人6> 查看到剩余票数[1]
<路人7> 查看到剩余票数[1]
<路人8> 查看到剩余票数[1]
<路人9> 查看到剩余票数[1]
<路人0> 购票成功

---

 互斥锁与join

使用join可以将并发变成串行，互斥锁的原理也是将并发变成串行，那我们直接使用join就可以了啊，为何还要互斥锁？

from multiprocessing import Process
import json
import time


def search(name):
    time.sleep(1)   # 模拟网络延迟
    dic = json.load(open("db.txt", 'r', encoding="utf-8"))
    print("<%s> 查看到剩余票数[%s]" % (name, dic["count"]))


def get(name):
    time.sleep(1)    # 模拟网络延迟
    dic = json.load(open("db.txt", 'r', encoding="utf-8"))
    if dic["count"] > 0:
        dic["count"] -= 1
        time.sleep(2)    # 模拟网络延迟(支付，传数据)
        json.dump(dic, open("db.txt", 'w', encoding="utf-8"))
        print("<%s> 购票成功" % name)
    else:
        print("<%s> 购票失败" % name)


def task(name):
    search(name)
    get(name)


if __name__ == "__main__":
    for i in range(10):
        p = Process(target=task, args=("路人%s" % i, ))
        p.start()
        p.join()

执行结果

<路人0> 查看到剩余票数[1]
<路人0> 购票成功
<路人1> 查看到剩余票数[0]
<路人1> 购票失败
<路人2> 查看到剩余票数[0]
<路人2> 购票失败
<路人3> 查看到剩余票数[0]
<路人3> 购票失败
<路人4> 查看到剩余票数[0]
<路人4> 购票失败
<路人5> 查看到剩余票数[0]
<路人5> 购票失败
<路人6> 查看到剩余票数[0]
<路人6> 购票失败
<路人7> 查看到剩余票数[0]
<路人7> 购票失败
<路人8> 查看到剩余票数[0]
<路人8> 购票失败
<路人9> 查看到剩余票数[0]
<路人9> 购票失败

发现使用join将并发改成串行，确实能保证数据安全，但问题是连查票操作也变成只能一个一个人去查了，很明显大家查票时应该是并发地去查询而无需考虑数据准确与否，此时join与互斥锁的区别就显而易见了，join是将一个任务整体串行，而互斥锁的好处则是可以将一个任务中的某一段代码串行，比如只让task函数中的get任务串行

def task(name,):
    search(name) # 并发执行

    lock.acquire()
    get(name) #串行执行
    lock.release()

---

总结

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行地修改，速度变慢了，但牺牲了速度却保证了数据安全。

虽然可以用文件共享数据实现进程间通信，但问题是：

1、效率低（共享数据基于文件，而文件是硬盘上的数据）

2、需要自己加锁处理