线程同步与死锁-优快云博客

本文链接：https://blog.youkuaiyun.com/Assassin567/article/details/104283280

同步的概念

同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。

"同"字从字面上容易理解为一起动作

其实不是，"同"字应是指协同、协助、互相配合。

如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B执行，再将结果给A;A再继续操作。

解决线程同时修改全局变量的方式
对于上一小节提出的那个计算错误的问题，可以通过线程同步来进行解决

思路，如下:
系统调用t1，然后获取到g_num的值为0，此时上一把锁，即不允许其他线程操作g_num
t1对g_num的值进行+1
t1解锁，此时g_num的值为1，其他的线程就可以使用g_num了，而且是g_num的值不是0而是1
同理其他线程在对g_num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
threading模块中定义了Lock类，可以方便的处理锁定：

lock = threading.Lock() #创建锁

lock.acquire() #上锁

lock.release() #解锁

如果这个锁之前是没有上锁的，那么acquire不会堵塞
如果在调用acquire对这个锁上锁之前它已经被其他线程上了锁，那么此时acquire会堵塞，直到这个锁被解锁为止

使用互斥锁自加：

from threading import Thread
from threading import Lock
import time
g_num = 0
# 创建一个全局锁对象
glock = Lock()
def work1(num):
    global g_num
    glock.acquire()# 给该线程加锁
    for i in range(num):
        g_num+=1
    glock.release()#解锁
    print("in work1-->",g_num)

def work2(num):
    global g_num
    glock.acquire()
    for i in range(num):
        g_num+=1
    glock.release()
    print("in work2-->",g_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 in-->",g_num)

运行结果：

in work1--> 1000000
in work2--> 2000000
main in--> 2000000

死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子
简单来说就是：两个线程占用一个资源，互不相让，导致程序堵塞

from threading import Thread
from threading import Lock
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()  # 给lock1上锁
    print("work2---->")
    lock1.release() # 进行解锁
    lock2.release()

if __name__ == '__main__':
    t1 = Thread(target=work1,args=(100000,)) # 创建线程t1
    t2 = Thread(target=work2,args=(100000,))# 创建线程t2
    t1.start() # 启动线程
    t2.start()

运行结果：
在这里插入图片描述

避免死锁
程序设计时要尽量避免（银行家算法）
添加超时时间等
附录-银行家算法
[背景知识]
一个银行家如何将一定数目的资金安全地借给若干个客户，使这些客户既能借到钱完成要干的事，同时银行家又能收回全部资金而不至于破产，这就是银行家问题。这个问题同操作系统中资源分配问题十分相似：银行家就像一个操作系统，客户就像运行的进程，银行家的资金就是系统的资源。

[问题的描述]

一个银行家拥有一定数量的资金，有若干个客户要贷款。每个客户须在一开始就声明他所需贷款的总额。若该客户贷款总额不超过银行家的资金总数，银行家可以接收客户的要求。客户贷款是以每次一个资金单位（如1万RMB等）的方式进行的，客户在借满所需的全部单位款额之前可能会等待，但银行家须保证这种等待是有限的，可完成的。

例如：有三个客户C1，C2，C3，向银行家借款，该银行家的资金总额为10个资金单位，其中C1客户要借9各资金单位，C2客户要借3个资金单位，C3客户要借8个资金单位，总计20个资金单位。某一时刻的状态如图所示。

在这里插入图片描述
对于a图的状态，按照安全序列的要求，我们选的第一个客户应满足该客户所需的贷款小于等于银行家当前所剩余的钱款，可以看出只有C2客户能被满足：C2客户需1个资金单位，小银行家手中的2个资金单位，于是银行家把1个资金单位借给C2客户，使之完成工作并归还所借的3个资金单位的钱，进入b图。同理，银行家把4个资金单位借给C3客户，使其完成工作，在c图中，只剩一个客户C1，它需7个资金单位，这时银行家有8个资金单位，所以C1也能顺利借到钱并完成工作。最后（见图d）银行家收回全部10个资金单位，保证不赔本。那麽客户序列{C1，C2，C3}就是个安全序列，按照这个序列贷款，银行家才是安全的。否则的话，若在图b状态时，银行家把手中的4个资金单位借给了C1，则出现不安全状态：这时C1，C3均不能完成工作，而银行家手中又没有钱了，系统陷入僵持局面，银行家也不能收回投资。