python中的 同步与异步 互斥锁 和 死锁

同步与异步：

同步：指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去。

异步：指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。

同步是阻塞模式，异步是非阻塞模式。

我的理解：同步是指两件事情有关联，其中一件事情要等待另外一件事情的进行。异步的意思是两件事情毫无关联。

互斥锁：

不加锁：
代码演示：

import threading
from threading import Thread

num = 0

def work1(n):
    global num
    for i in range(n):
        num +=1
    print("in work1:",num)

def work2(n):
    global num
    for i in range(n):
        num += 1
    print("in work2:",num)

def main():
    t1 = Thread(target=work1,args=(1000000,))
    t2 = Thread(target=work2,args=(1000000,))

    t1.start()
    t2.start()
    t2.join()

if __name__ == '__main__':
    main()
    print("main:",num)

运行结果：

加锁：
代码演示：

import threading
from threading import Thread

num = 0

lock = threading.Lock() #创建一个锁

def work1(n):
    global num
    lock.acquire() #加锁
    for i in range(n):
        num +=1
    lock.release() #解锁
    print("in work1:",num)

def work2(n):
    global num
    lock.acquire() #加锁
    for i in range(n):
        num += 1
    lock.release() #解锁
    print("in work2:",num)

def main():
    t1 = Thread(target=work1,args=(1000000,))
    t2 = Thread(target=work2,args=(1000000,))

    t1.start()
    t2.start()
    t2.join()

if __name__ == '__main__':
    main()
    print("main:",num)

运行结果：

锁的好处：确保了某段关键代码只能由一个线程从头到尾完整地执行。

锁的坏处：阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁。

死锁：

死锁就是一直等待对方释放锁的情景
死锁的结果会造成程序的停止响应, 不能再处理其他的任务了

死锁示例
代码演示：

from threading import Lock
from  threading import Thread

lock1 = Lock()
lock2 = Lock()

def work1(num):
    lock1.acquire()  #lock1上锁
    
    print("in work1")
    lock2.acquire()  #lock2上锁
    print("work1----")
    lock2.release()  #lock2解锁
    lock1.release()  #lock1解锁

def work2(num):
    lock2.acquire()  #lock2加锁
    print("in work2")
    lock1.acquire()  #lock2加锁
    print("work2-----")
    lock1.release() #lock1解锁
    lock2.release() #lock2解锁

if __name__ == '__main__':
    t1 = Thread(target=work1,args=(1000000,))
    t2 = Thread(target=work2,args=(1000000,))
    t1.start()
    t2.start()

运行结果：

避免死锁
代码演示：

from threading import Lock
from  threading import Thread
import time

lock1 = Lock()
lock2 = Lock()

def work1(num):
    lock1.acquire()  #lock1上锁
    time.sleep(1)
    print("in work1")
    lock2.acquire()  #lock2上锁
    print("work1----")
    lock2.release()  #lock2解锁
    lock1.release()  #lock1解锁

def work2(num):
    lock2.acquire()  #lock2加锁
    print("in work2")
    lock1.acquire()  #lock2加锁
    print("work2-----")
    lock1.release() #lock1解锁
    lock2.release() #lock2解锁

if __name__ == '__main__':
    t1 = Thread(target=work1,args=(1000000,))
    t2 = Thread(target=work2,args=(1000000,))
    t1.start()
    t2.start()

运行结果：