1.GIL锁(Global Interpreter Lock)

　　Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。

　　对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。

　　GIL本质就是一把互斥锁，既然是互斥锁，所有互斥锁的本质都一样，都是将并发运行变成串行，以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。

python程序运行的过程

1.在内存中加载生成一个进程的内存空间

2.这个内存空间中有有解释器的代码和你要执行进程的代码

3.进程中又有多个线程

4.由于python是一门解释型语言, CPU无法识别python的代码, 所以必须经过解释器来对代码进行编译成二进制的代码(.pyc)

5.但是由于CPython解释器的特性,有一个GIL锁,同一时刻只能有一个线程能进入解释器进行编译

6.当一个线程运行了指定数量的字节码指令或者遇到I/O操作时, GIL锁才会被释放, 后面的线程再去抢GIL锁重复前面的操作

7.所以对于同一个进程中的多个线程是无法同时使用多个CPU的

2.同步锁

　　当同时异步提交多个线程, 这些线程都有相同的数据修改操作, 且在数据修改操作之前有I/O操作或者网络延时, 这个时候可能多个进程拿到的数据是相同的, 然后修改后的数据也是相同的, 这样就会造成数据混乱问题. 这个时候就能用到同步锁, 在拿数据前加个锁,修改完之后再释放, 这样就不会有数据混乱的问题.

from threading import Thread
import os,time
def work():
    global n
    temp=n
    time.sleep(0.1)
    n=temp-1
if __name__ == '__main__':
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #结果可能为99

from threading import Thread,Lock
import os,time
def work():
    global n
    lock.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

 死锁和递归锁

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

import time
from threading import Thread, Lock, RLock

def func1(lockA,lockB):
    lockA.acquire()
    time.sleep(1)
    print("锁A")
    lockB.acquire()
    print("锁B")
    lockB.release()
    lockA.release()

def func2(lockA,lockB):
    lockB.acquire()
    print("锁A")
    lockA.acquire()
    print("锁B")
    lockA.release()
    lockB.release()

if __name__ == '__main__':
    lockA = Lock()
    lockB = Lock()
    t1 = Thread(target=func1, args=(lockA,lockB ))
    t1.start()
    t2 = Thread(target=func2, args=(lockA, lockB))
    t2.start()

 

解决方案: 递归锁, 在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

import time
from threading import Thread, Lock, RLock

def func1(lockA,lockB):
    lockA.acquire()
    time.sleep(1)
    print("锁A")
    lockB.acquire()
    print("锁B")
    lockB.release()
    lockA.release()

def func2(lockA,lockB):
    lockB.acquire()
    print("锁A")
    lockA.acquire()
    print("锁B")
    lockA.release()
    lockB.release()

if __name__ == '__main__':
    lockA = lockB = RLock()
    t1 = Thread(target=func1, args=(lockA,lockB ))
    t1.start()
    t2 = Thread(target=func2, args=(lockA, lockB))
    t2.start()

 

3.GIL锁与同步锁LOCK

锁的目的是都是为了保护共享数据, 同一时刻只能有一个线程来修改共享的数据

GIL是解释器级别的, 保护的是解释器级别的数据, 比如垃圾回收的数据.

Lock是保护用户自己开发的应用程序的数据.

过程分析:所有线程抢的是GIL锁, 或者书所有线程强的是执行权限

线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果

 

 互斥锁和join的区别

start后立即join: 任务内的所有代码都是串行执行的, 而加锁, 只是加锁的部分即修改共享数据的部分是串行的.

但从保证数据安全方面, 二者都可以实现, 但很明显是加锁的效率更高.