鎖：

from threading import Thread,Lock
# 建立一個互斥鎖
mutex = Lock()

def task1():
    # 鎖定
    mutex.acquire()
    for i in range(100):
        print("===================")
    # 開啟
    mutex.release()
def task2():
    mutex.acquire()
    for i in range(100):
        print("!!!!!!!!!!!!!!!!!!")
    mutex.release()

 
def task3():
    mutex.acquire()
    for i in range(100):
        print("********************")
    mutex.release()

t1 = Thread(target=task1)
t2 = Thread(target=task2)
t3 = Thread(target=task3)

t1.start()
t2.start()
t3.start()

死鎖：

from threading import Thread,Lock
 
import time,random

mutex1 = Lock()   #建立一個鎖1
mutex2 = Lock()   #建立一個鎖2
def fun1():
    mutex1.acquire()
    print("搶到了鎖1")
    time.sleep(1)
    mutex2.acquire()
    print("搶到了鎖2")

    mutex2.release()
    print("釋放了鎖2")

    mutex1.release()
    print("釋放了鎖1")


def fun2():

    mutex2.acquire()
    
 
print("搶到了鎖2")

    time.sleep(1)

    mutex1.acquire()
    print("搶到了鎖1")



    mutex1.release()
    print("釋放了鎖2")

    mutex2.release()
    print("釋放了鎖1")

# def fun3():
#     fun1()
#     fun2(

t1 = Thread(target=fun1)
t1.start()
t2 = Thread(target=fun2)
t2.start()

from threading import Thread,Lock,current_thread,RLock
import time
# 叉子
locka = RLock()
# 盤子
lockb = RLock()



def task1():
    print(current_thread())
    locka.acquire()
    print("搶到叉子 需要盤子")
    time.sleep(0.1)
    lockb.acquire()
    print("吃飯")

    lockb.release()
    locka.release()

def task2():
    print(current_thread())
    lockb.acquire()
    print("搶到盤子 需要叉子")
    time.sleep(0.1)
    locka.acquire()

    print("吃飯")
    locka.release()
    lockb.release()


t1 = Thread(target=task1)
t1.start()
t2 = Thread(target=task2)
t2.start()

# 死鎖發生的條件  有多個執行緒 多個鎖   如果只有一個鎖 無論是LOCK RLOK 卡不死(前提是邏輯上沒有錯誤)
# RLock 就算你的程式碼邏輯不對 同一個執行緒多次對一個鎖執行acquire 也不會卡死

單個鎖：（遞迴鎖/重入鎖）

 單個鎖能不能鎖死____答案是肯定的：

from threading import  Thread,Lock,RLock,current_thread

l = Lock()  # 互斥鎖

# l.acquire()
# print("zxxzxxxzxzx")
# l.acquire()
# print("aaaaaaaaa")


# RLock   遞迴鎖 重入鎖  可以多次執行acquire

# lock = RLock()
#
# lock.acquire()
# print("aaaaaaaaaaa")
# lock.acquire()
# print("bbbbbbbbbbb")



import time
lock = RLock()
# 對於同一個執行緒而言 可以多次acquire  其他執行緒會被阻塞
def task():
    lock.acquire()
    for i in range(5):
        time.sleep(1)
        print(current_thread())
    lock.release()

Thread(target=task).start()
Thread(target=task).start()

訊號量：（也是一種鎖）

from threading import Thread,Semaphore,current_thread,active_count

import time
# 用於控制 同時執行被鎖定程式碼的執行緒數量   也就是執行緒的併發數量
# 也是一種鎖
sm = Semaphore(1)

def task():
    sm.acquire()
    for i in range(10):
        print(current_thread())
        time.sleep(0.5)
    sm.release()

def task2():
     for i in range(10):
        print(current_thread())
        time.sleep(0.5)


for i in range(5):
    Thread(target=task).start()
    Thread(target=task2).start()
print(active_count())