同步锁 死锁 递归锁
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
以上是关于同步锁 死锁 递归锁的主要内容,如果未能解决你的问题,请参考以下文章
Java锁机制:乐观锁 悲观锁 自旋锁 可重入锁 读写锁 公平锁 非公平锁 共享锁 独占锁 重量级锁 轻量级锁 偏向锁 分段锁 互斥锁 同步锁 死锁 锁粗化 锁消除