一、造成死锁的原因

1、在多线程程序中，死锁问题很大一部分是由于线程同时获取多个锁造成的。
2、在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
3、尽管死锁很少发生，但一旦发生就会造成应用的停止响应。

二、产生死锁的四个原因

1.针对多个资源

1、互斥条件:一个资源每次只能被一个线程使用。
2、请求与保持条件:一个线程因请求资源而阻塞时，对已获得的资源保持不放。(举例:A线程获取到了鱼,再没有得到熊掌的时候,A线程是不会放弃鱼的)
3、不剥夺条件:线程已获得的资源，在末使用完之前，不能强行剥夺。(举例:A线程获取到了鱼,在我没有释放鱼时,B线程是不可以对我的鱼进行强行剥夺)
4、循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系。

三、第一种死锁：没有释放锁

例如:

import threading
import time

# 代表鱼的锁
mutex_Yu = threading.Lock()
# 代表熊掌的锁
mutex_Xiongzhang = threading.Lock()


class MyThread1(threading.Thread):

    def run(self):
        mutex_Yu.acquire()  # 得到🐟
        print('线程1已经得到鱼了')
        time.sleep(1)

        mutex_Xiongzhang.acquire()
        print('线程1得到熊掌')
        mutex_Xiongzhang.release()
        mutex_Yu.release()


class MyThread2(threading.Thread):

    def run(self):
        mutex_Xiongzhang.acquire()
        print('线程2已经得到熊掌了')
        time.sleep(1)

        mutex_Yu.acquire()
        print('线程2已经得到🐟了')
        mutex_Yu.release()
        mutex_Xiongzhang.release()

if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

执行结果：

解决方法：让多个线程交叉有序的竞争多个资源

#让多个线程交叉有序的竞争多个资源
import threading
import time
# 代表🐟的锁
mutex_Yu = threading.Lock()
# 代表熊掌的锁
mutex_Xiongzhang = threading.Lock()

class MyThread1(threading.Thread):

    def run(self):
        while True:
            mutex_Yu.acquire()  # 得到🐟
            print('线程1已经得到鱼了')
            time.sleep(1)
            mutex_Yu.release()   #释放鱼对应锁

            mutex_Xiongzhang.acquire()  # 得到熊掌
            print('线程1得到熊掌')
            time.sleep(1)
            mutex_Xiongzhang.release()    #释放熊掌对应锁

class MyThread2(threading.Thread):

    def run(self):
        while True:
            mutex_Xiongzhang.acquire()   # 得到熊掌
            print('线程2已经得到熊掌了')
            time.sleep(1)
            mutex_Xiongzhang.release() #释放熊掌对应锁

            mutex_Yu.acquire()     # 得到🐟
            print('线程2已经得到鱼了')
            time.sleep(1)
            mutex_Yu.release()     #释放鱼对应锁

if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

四、第二种死锁：多次调用自己

已经获取到了资源锁了,但是还在源源不断的去获取当前资源锁

mutex_TianTang = threading.Lock()  # 去天堂的锁,其实是互斥锁。可以使用逻辑锁，这样就不会死锁了

class MyThread3(threading.Thread):
    def run(self):
        mutex_TianTang.acquire()
        print('线程3进入了天堂')
        time.sleep(1)
        self.run()  # 再次进入天堂
        mutex_TianTang.release()

执行结果

解决方法：将逻辑锁替换为互斥锁

mutex_TianTang=threading.RLock()  #Rlock就是逻辑锁，但是逻辑锁针对一个线程

class MyThread3(threading.Thread):
    def run(self):
        mutex_TianTang.acquire()
        print('线程3进入了天堂')
        time.sleep(1)
        self.run()  # 再次进入天堂
        mutex_TianTang.release()


if __name__ == '__main__':
    t3 = MyThread3()
    t3.start()

执行结果

逻辑锁和互斥锁的区别

逻辑锁和互斥锁都是线程同步的机制，但是它们的实现方式不同。逻辑锁是一种更高级别的锁，它可以区分读和写，允许多个线程同时访问对象，而互斥锁则是一种最基本的锁，它只允许一个线程访问对象。
逻辑锁通常用于大量读少量写的环境，因为它可以允许多个线程同时读取对象，从而提高了效率。而互斥锁则适用于需要保证临界区代码互斥执行的情况，因为它只允许一个线程访问对象，从而避免了竞争条件的发生。
另外，逻辑锁的实现比互斥锁更加复杂，因为它需要区分读和写操作，并且需要保证写操作的互斥性。而互斥锁则相对简单，只需要保证临界区代码的互斥执行即可。