Python学习之互斥锁和死锁

Python——互斥锁

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

2.如何控制，就是加锁处理，而互斥锁就是互相排斥，假设把多个进程比喻成多个人，互斥锁的工作原理是多个人都要去争抢同一个资源：比如抢一个房间，谁先抢到这个资源就暂时先占为己有然后上个锁，然后在他占用的时间段内别人是要等他用完

hreading模块中定义了Lock类，可以方便的处理锁定：

1.创建锁
mutex = threading.Lock()

2.锁定
mutex.acquire([timeout])

3.释放
mutex.release()

其中，锁定方法acquire可以有一个超时时间的可选参数timeout。如果设定了timeout，则在超时后通过返回值可以判断是否得到了锁，从而可以进行一些其他的处理。
使用互斥锁实现上面的例子的代码如下：

from multiprocessing import Process,Lock
import time,random
#互斥锁：必须是lock.acquire()一次，然后lock.release()释放一次，才能继续lock.acquire()
#互斥锁和join区别
#大前提：二者的原理都是一样的，都是将并发变成串行，从而保证有序
#区别：join是按照认为指定的顺序执行，而互斥锁是所有的进程平等的竞争，谁先抢到谁执行
mutex=Lock()

#两个线程都在抢着对这个锁进行上锁，如果有一方成功上锁，那么导致另外一方会堵塞（一直等待），到这个锁被解开为之
thnum=0
class MyThread(threading.Thread):
	def run(self):
		mutex.acquire()
		for i in range(10000):
			global thnum
			thnum+=1	
		print(thnum)
		mutex.release()
 
def test():
	global thnum
	mutex.acquire()  #等待可以上锁，通知而不是轮训，没有占用CPU
	for i in range(10000):
		thnum+=1
	print(thnum)
	mutex.release()#解锁

死锁概念

在多道程序系统中，由于多个进程的并发执行，改善了系统资源的利用率并提高了系统的处理能力。然而，多个进程的并发执行也带来了新的问题——死锁。所谓死锁是指多个进程因竞争资源而造成的一种僵局，若无外力作用，这些进程都将无法向前推进。

代码示意

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('\033[41m%s 拿到A锁\033[0m' %self.name)

        mutexB.acquire()
        print('\033[42m%s 拿到B锁\033[0m' %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('\033[43m%s 拿到B锁\033[0m' %self.name)
        time.sleep(2)

        mutexA.acquire()
        print('\033[44m%s 拿到A锁\033[0m' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(5):
        t=MyThread()
        t.start()