线程-GIL锁

Posted hedger-lee

tags:

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

GIL和锁

全局解释器锁GIL

Python 解释器中可以“运行”多个线程,但在任意时刻只有一个线程在解释器中运行。
对Python虚拟机的访问由全局解释器锁(GIL)来控制,正是这个锁能保证同一时刻只有一个线程在运行。

在多线程环境中,Python 虚拟机按以下方式执行:

a、设置 GIL;

b、切换到一个线程去运行;

c、运行指定数量的字节码指令或者线程主动让出控制(可以调用 time.sleep(0));

d、把线程设置为睡眠状态;

e、解锁 GIL;

d、再次重复以上所有步骤。
  

同步锁

import threading
R=threading.Lock()
R.acquire()
‘‘‘
对公共数据的操作
‘‘‘
R.release()
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,由原来的并发执行变成串行,牺牲了执行效率保证了数据安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    #未加锁的代码并发运行
    time.sleep(3)
    print(‘%s start to run‘ %current_thread().getName())
    global n
    #加锁的代码串行运行
    lock.acquire()
    temp=n
    time.sleep(0.5)
    n=temp-1
    lock.release()

if __name__ == ‘__main__‘:
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    stop_time=time.time()
    print(‘主:%s n:%s‘ %(stop_time-start_time,n))

死锁

是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。

此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程

from threading import Lock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()

递归锁

在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。

from threading import RLock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()

典型事例:科学家吃面

问题

import time
from threading import Thread,Lock
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘%name)
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘%name)
    print(‘%s 吃面‘%name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘ % name)
    time.sleep(1)
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘ % name)
    print(‘%s 吃面‘ % name)
    noodle_lock.release()
    fork_lock.release()

for name in [‘哪吒‘,‘egon‘,‘yuan‘]:
    t1 = Thread(target=eat1,args=(name,))
    t2 = Thread(target=eat2,args=(name,))
    t1.start()
    t2.start()

递归锁解决

import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name):
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘%name)
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘%name)
    print(‘%s 吃面‘%name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print(‘%s 抢到了叉子‘ % name)
    time.sleep(1)
    noodle_lock.acquire()
    print(‘%s 抢到了面条‘ % name)
    print(‘%s 吃面‘ % name)
    noodle_lock.release()
    fork_lock.release()

for name in [‘哪吒‘,‘egon‘,‘yuan‘]:
    t1 = Thread(target=eat1,args=(name,))
    t2 = Thread(target=eat2,args=(name,))
    t1.start()
    t2.start()

以上是关于线程-GIL锁的主要内容,如果未能解决你的问题,请参考以下文章

GIL全局解释器锁和进程池.线程池

GIL锁,线程池,同步异步

Python入门学习-DAY36-GIL全局解释器锁死锁现象与递归锁信号量Event事件线程queue

python GIL锁

27 Apr 18 GIL 多进程多线程使用场景 线程互斥锁与GIL对比 基于多线程实现并发的套接字通信 进程池与线程池 同步异步阻塞非阻塞

GIL全局解释器锁