全局解释器锁GIL & 线程锁
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: 任务内的所有代码都是串行执行的, 而加锁, 只是加锁的部分即修改共享数据的部分是串行的.
但从保证数据安全方面, 二者都可以实现, 但很明显是加锁的效率更高.
上一篇: I-team 博客全文检索 Elasticsearch 实战
下一篇: 众筹后的新产品上市如何做推广