同步锁 死锁 递归锁

Posted zx125

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了同步锁 死锁 递归锁相关的知识,希望对你有一定的参考价值。

多线程

同步锁(互斥锁)

解决什么问题?

同步锁解决什么问题?

多个线程操作同一个数据,可能会发生数据错乱的问题,因为一个线程拿到数据后,还没来得及对数据进行操作,cpu就有可能去执行另外一个线程,另外一个线程拿到的则是之前线程没有处理完的数据,如下

import threading
import time
count=20

def zx():

    global count
    print(count)
    time.sleep(0.001)
    count-=1

t_list=[]
for t in range(20):
    t=threading.Thread(target=zx)
    t_list.append(t)
    t.start()

for i in t_list:
    i.join()

print(count)

20
20
20
20
20
20
18
18
18
15
15
15
13
11
11
8
8
8
6
6
0

解决方法

可以强制让cpu执行完一部分代码后,才能去调用其他线程,这样可以确保,其他线程拿到想要的正确数据,但是这一部分是串行的。

具体实现的过程

一.100个线程去抢GIL锁,即抢执行权限

二.肯定有一个线程先抢到GIL(暂且称为线程1),然后开始执行,一旦执行就会拿到lock.acquire()

三.极有可能线程1还未运行完毕,就有另外一个线程2抢到GIL,然后开始运行,但线程2发现互斥锁lock还未被线程1释放,于是阻塞,被迫交出执行权限,即释放GIL

四.直到线程1重新抢到GIL,开始从上次暂停的位置继续执行,直到正常释放互斥锁lock,然后其他的线程再重复2 3 4的过程

import threading
import time
count=20

lock=threading.Lock()

def zx():

    global count
    lock.acquire()
    print(count)
    time.sleep(0.001)
    count-=1
    lock.release()

t_list=[]
for t in range(20):
    t=threading.Thread(target=zx)
    t_list.append(t)
    t.start()

for i in t_list:
    i.join()

print(count)

20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0

死锁

所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁

比如有两个线程,线程1拿到了A锁,但是他只有拿到B锁才能把A锁释放,线程2拿到了B锁,他要拿到A锁才能释放B锁,结果这两个线程就死掉了

import threading
import time

class MyThreading(threading.Thread):

    def run(self):
        self.run1()
        self.run2()

    def run1(self):
        A.acquire()
        print(self.name+"拿到了锁A")
        B.acquire()
        print(self.name+"拿到了锁B")
        B.release()
        print(self.name+"释放了锁B")
        A.release()
        print(self.name+"释放了锁A")

    def run2(self):
        B.acquire()
        print(self.name+"拿到了锁B")
        time.sleep(2)
        A.acquire()
        print(self.name+"拿到了锁A")
        A.release()
        print(self.name+"释放了锁A")
        B.release()
        print(self.name+"释放了锁B")

if __name__ == '__main__':
    A=threading.Lock()
    B=threading.Lock()
    for t in range(5):
        t=MyThreading()
        t.start()

Thread-1拿到了锁A
Thread-1拿到了锁B
Thread-1释放了锁B
Thread-1释放了锁A
Thread-1拿到了锁B
Thread-2拿到了锁A

如何解决死锁

使用递归锁

递归锁

相当于把一块用了很多锁的代码块,看做一个整体,当这个代码块所有的锁都释放了,才能被其他的方法或者线程拿到锁

递归锁的实现原理很简单,当加锁,递归锁的引用计数+1,解锁则-1.当引用计数为0,才能被其他线程或者方法拿到锁。

import threading
import time

class MyThreading(threading.Thread):

    def run(self):
        self.run1()
        self.run2()

    def run1(self):
        D.acquire()
        print(self.name+"D==1")
        D.acquire()
        print(self.name+"D==2")
        D.release()
        print(self.name+"D==1")
        D.release()
        print(self.name+"D==0")

    def run2(self):
        D.acquire()
        print(self.name+"D==1")
        time.sleep(2)
        D.acquire()
        print(self.name+"D==2")
        D.release()
        print(self.name+"D==1")
        D.release()
        print(self.name+"D==0")

if __name__ == '__main__':
    D=threading.RLock()
    for t in range(5):
        t=MyThreading()
        t.start()

这里的==被转义的,将就着看
Thread-1D==1
Thread-1D==2
Thread-1D==1
Thread-1D==0
Thread-1D==1
Thread-1D==2
Thread-1D==1
Thread-1D==0
Thread-2D==1
Thread-2D==2
Thread-2D==1
Thread-2D==0
Thread-2D==1
Thread-2D==2
Thread-2D==1
Thread-2D==0
Thread-4D==1
Thread-4D==2
Thread-4D==1
Thread-4D==0
Thread-4D==1
Thread-4D==2
Thread-4D==1
Thread-4D==0
Thread-3D==1
Thread-3D==2
Thread-3D==1
Thread-3D==0
Thread-5D==1
Thread-5D==2
Thread-5D==1
Thread-5D==0
Thread-5D==1
Thread-5D==2
Thread-5D==1
Thread-5D==0
Thread-3D==1
Thread-3D==2
Thread-3D==1
Thread-3D==0

以上是关于同步锁 死锁 递归锁的主要内容,如果未能解决你的问题,请参考以下文章

并发&并行 同步&异步 GIL 任务 同步锁 死锁 递归锁

同步锁(互斥锁),GIL锁(解释器层面的锁),死锁与递归锁

Python程序中的线程操作-锁

Java锁机制:乐观锁 悲观锁 自旋锁 可重入锁 读写锁 公平锁 非公平锁 共享锁 独占锁 重量级锁 轻量级锁 偏向锁 分段锁 互斥锁 同步锁 死锁 锁粗化 锁消除

并发编程--一堆锁,GIL,同步异步,Event事件

同步-同步锁-死锁-线程交互-线程综合示例