gopython 获取python 全局线程锁失败_python线程互斥锁递归锁死锁
一、为什么有了GIL还要给线程加锁
先说一下GIL，所谓的GIL，也叫全局解释器锁，它限制了任何时候都只能有一个线程进入CPU进行计算，所以python所谓的多线程并不能真正的并行。
那为什么有了GIL还需要给线程加锁呢？不是直接一个线程处理完一个数据才轮到下一个线程进行吗？线程锁不是多此一举？
解决这个问题，我们得更深入到底层看看代码是怎么在CPU上运行的。在这里引入一个概念：原子操作
什么是原子操作
所谓的原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，不会运行到一半，然后CPU切换到另外的线程。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱。
像 C语言的i++和python中的+=，-=，*=，/=都不是原子操作，他们在被翻译成机器指令时实际上是分三个步骤的，比如 i-=1 这个操作本质是这样的：
1、先把内存中的1存储在CPU的寄存器中
2、CPU进行计算，减一
3、将寄存器的内容写到内存中。
在1-3这个过程中，线程完全有可能被切换，所以可能导致线程数据的不安全。所以加锁是必要的。我们看看下面的一个例子。
from threading importLock,Thread
n= 10000000
deffunc():globalnfor i in range(1000000):
n-= 1t_lst=[]for i in range(10):
t= Thread(target=func)
t.start()
t_lst.append(t)for i int_lst:i.join()print(n)
上面代码过程就是用十个线程去将一个数减到0，但是运行结果如下：
所以这就验证了线程数据的不安全性。下面是加锁的版本
from threading importLock,Thread
n= 10000000
deffunc(lock):globalnfor i in range(1000000):
lock.acquire()
n= n - 1lock.release()
t_lst=[]
lock=Lock()for i in range(10):
t= Thread(target=func,args=(lock,))
t.start()
t_lst.append(t)for i int_lst:i.join()print(n)
二、互斥锁
同一时间只能有一个任务持有互斥锁，而且只有这个任务可以对互斥锁进行解锁。当无法获取锁时，线程进入睡眠等待状态。
其实上面的例子用到的就是互斥锁。当一个线程在操作数据n时候，其他线程是不允许对n进行操作的。
三、死锁
所谓的死锁就是指由多个线程直接，各自持有某些资源，又在申请其他线程所持有的资源，各自坚持着都不释放资源，一直坚持着，这就是死锁。
先不下明确的定义，后面再仔细讨论。我们先来看看一个死锁的例子。
科学家吃面问题：几个科学家一起吃面，必须先申请面和申请到叉子才能开吃。
importtimefrom threading importThread,Lockdefeat1(noodle_lock,fork_lock,name):
noodle_lock.acquire()print(name,'拿到了面')
fork_lock.acquire()print(name,'拿到了叉子')
time.sleep(1)print(name,'吃到了面')
fork_lock.release()
noodle_lock.release()print(name, '放下了面')print(name, '放下了叉子')defeat2(noodle_lock,fork_lock,name):
fork_lock.acquire()print(name, '拿到了叉子')
noodle_lock.acquire()print(name, '拿到了面')print(name, '吃到了面')
noodle_lock.release()print(name, '放下了面')
fork_lock.release()print(name, '放下了叉子')
name_list1= ['特斯拉','牛顿']
name_list2= ['法拉第','爱迪生']
noodle_lock=Lock()
fork_lock=Lock()for i inname_list1:
t= Thread(target=eat1,args=(noodle_lock,fork_lock,i))
t.start()for i inname_list2:
t= Thread(target=eat2, args=(noodle_lock, fork_lock, i))
t.start()
一个拿着叉子在等面，一个拿着面在等叉子。一直僵持着，这就是死锁。
四、递归锁
所谓的递归锁就是指一个线程可以多次申请同一把锁，但是不会造成死锁。这就可以用来解决上面的死锁问题
import time
from threading import Thread,RLock
def eat1(noodle_lock,fork_lock,name):
noodle_lock.acquire()
print(name,'拿到了面')
fork_lock.acquire()
print(name,'拿到了叉子')
time.sleep(1)
print(name,'吃到了面')
fork_lock.release()
noodle_lock.release()
print(name, '放下了面')
print(name, '放下了叉子')
def eat2(noodle_lock,fork_lock,name):
fork_lock.acquire()
print(name, '拿到了叉子')
noodle_lock.acquire()
print(name, '拿到了面')
print(name, '吃到了面')
noodle_lock.release()
print(name, '放下了面')
fork_lock.release()
print(name, '放下了叉子')
name_list1 = ['特斯拉','牛顿']
name_list2 = ['法拉第','爱迪生']
noodle_lock=fork_lock = RLock()
for i in name_list1:
t = Thread(target=eat1,args=(noodle_lock,fork_lock,i))
t.start()
for i in name_list2:
t = Thread(target=eat2, args=(noodle_lock, fork_lock, i))
t.start()
下面在仔细讨论一下死锁。
五、死锁产生的四个必要条件
1、互斥条件：当一个进程在访问一个资源的时候，其他进程只能等待。即任何时候一个资源只能给一个进程使用。
2、不可剥夺条件:一个进程在访问一个资源时，其他进程只能等该进程使用完释放资源，不可强行剥夺。
3、请求和保持条件：当一个进程在申请它所需的资源时，并不会释放已有的资源。
4、在发生死锁时必然存在一个进程等待队列{P1,P2,…,Pn},其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路，环路中每一个进程所占有的资源同时被另一个申请，也就是前一个进程占有后一个进程所深情地资源。
只要发生死锁，那么上面四个条件一定都成立。所以只要破坏其中一个，就可以打破死锁。