其他分享
首页 > 其他分享> > GIL全局解释器锁 | 死锁现象

GIL全局解释器锁 | 死锁现象

作者:互联网

全局解释器锁GIL

Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中,同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程,但在任意时刻只有一个线程在解释器中运行。
  对Python虚拟机的访问由全局解释器锁(GIL)来控制,正是这个锁能保证同一时刻只有一个线程在运行。

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

  a、设置 GIL;

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

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

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

  e、解锁 GIL;

  d、再次重复以上所有步骤。
  在调用外部代码(如 C/C++扩展函数)的时候,GIL将会被锁定,直到这个函数结束为止(由于在这期间没有Python的字节码被运行,所以不会做线程切换)编写扩展的程序员可以主动解锁GIL。

什么是GIL锁

点击查看详情
GIL (Global Interperter Lock) 称作全局解释器锁。
GIL并不是Python语言的特性,它是在实现Python解释器时引用的一个概念。GIL只在CPython解释器上存在。
不过,在Python的解释器中,使用最多的都是CPython解释器,所以我们不可避免的会遇到GIL。
在使用互斥锁解决代码中的资源竞争问题时,当一个线程执行时,会将全局共享的资源上锁,当线程执行完成后,将锁解开,释放资源,其他线程才能够使用。
GIL的作用与互斥锁的作用相似,是为了解决解释器中多个线程资源竞争的问题。

GIL锁:全局解释器锁,在解释器之上的一把大锁,线程必须获得这把锁,才能执行,只针对与cpython解释器

为什么开设全局解释锁GIL

1 全局解释器锁,GIL锁(cpython解释器的问题)
 同一个时刻,在一个进程中可以开多个线程,但只能有一条线程在执行
起初设置GIL仅仅是为了做垃圾回收,在当时还只有单核,并无多核。所以开了多条线程也不会被多个CPU调动执行,因为只有单核。线程拿到这把锁才能运行。在当时是没有问题,因为只有一个CPU。但是随着多核CPU的出现,假设电脑是四核,一个进程四条线程,理论一个线程一核,但是Python不行,在一个线程中开四条线程并不会被四个核运行,同一时刻只能有一个线程在一个核运行,就是因为GIL原因。
    -python需要做垃圾回收(gc)
    -垃圾回收线程,进行垃圾回收
    -设计了一个大锁(GIL锁),只有拿到这把锁的线程,才能执行
    -同一时刻,在一个进程中,可以开多个线程,但是只能有一条线程在执行
    -因此python不能利用多核优势
  

### 只针对与cpython解释器(其他解释器,包括其他语言不这样)
2 如果是计算密集型:要开进程
3 如果是io密集型:要开线程

验证GIL锁的存在

点击查看代码
from threading import Thread
import time
m = 100
def test():
    global m
    tmp = m
    tmp -= 1
    m = tmp
for i in range(100):
    t = Thread(target=test)
    t.start()
time.sleep(3)
print(m)


结果:
    0
    
"""
同一个进程下的多个线程虽然有GIL的存在不会出现并行的效果
但是如果线程内有IO操作还是会造成数据的错乱 这个时候需要我们额外的添加互斥锁
"""

GIL 解释器锁会在两种情况下释放

1.主动释放


遇到 IO 操作或者分配的 CPU 时间片到时间了。

注意,GIL存在的意义在于维护线程安全,x=10涉及到IO操作,如果也被当成普通的IO操作,主动交出GIL,那么一定会出现数据不安全问题,所以x=10一定是被区分对待了。

至于x=10如何实现的被区分对待,这其实很好理解,任何的io操作都是向操作系统发送系统调用,即调用操作系统的某一接口实现的,比如变量赋值操作肯定是调用了一种接口,文件读写操作肯定也是调用了一种接口,网络io也是调用了某一种接口,这就给区分对待提供了实现的依据,即变量赋值操作并不属于主动释放的范畴,这样GIL在线程安全方面才会有所作为

2.被动释放

python3.2之后定义了一个全局变量

/ Python/ceval.c /*

*static volatile int gil_drop_request = 0;

注意当只有一个线程时,该线程会一直运行,不会释放GIL,当有多个线程时

例如thead1,thread2

如果thread1一直没有主动释放掉GIL,那肯定不会让他一直运行下去啊

实际上在thread1运行的过程时,thread2就会执行一个cv_wait(gil,TIMEOUT)的函数

(默认TIMEOUT值为5milliseconds,但是可以修改),一旦到了时间,就会将全局变量

gil_drop_request = 1;,线程thread1就会被强制释放GIL,然后线程thread2开始运行并

返回一个ack给线程thread1,线程thread1开始调用cv_wait(gil,TIMEOUT

死锁

什么是死锁

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

点击查看死锁代码
from threading import Thread, Lock
import time

A = Lock()
B = Lock()


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        A.acquire()
        print('%s 抢到了A锁' % self.name)  # current_thread().name  获取线程名称
        B.acquire()
        print('%s 抢到了B锁' % self.name)
        time.sleep(1)
        B.release()
        print('%s 释放了B锁' % self.name)
        A.release()
        print('%s 释放了A锁' % self.name)

    def func2(self):
        B.acquire()
        print('%s 抢到了B锁' % self.name)
        A.acquire()
        print('%s 抢到了A锁' % self.name)
        A.release()
        print('%s 释放了A锁' % self.name)
        B.release()
        print('%s 释放了B锁' % self.name)

for i in range(10):
    obj = MyThread()
    obj.start()
 
"""就算知道锁的特性及使用方式 也不要轻易的使用 因为容易产生死锁现象"""

线程1 先开始执行func1,分布拿到AB锁,然后释放
线程1 先执行func2,先拿到了B锁,开始sleep
线程2 先拿到了A锁
这时候形成了僵局,线程2想要线程1手里的B锁,线程1想要线程2里的A锁。

解决死锁问题

点击查看代码
### 解决死锁问题  RLock:可重入,可以重复acquire,获得几次,就要释放几次
from threading import Thread, Lock,Rlock
import time


A = RLock()   # 解决死锁问题
B = A


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        A.acquire()
        print('%s 抢到了A锁' % self.name)  # current_thread().name  获取线程名称
        B.acquire()
        print('%s 抢到了B锁' % self.name)
        time.sleep(1)
        B.release()
        print('%s 释放了B锁' % self.name)
        A.release()
        print('%s 释放了A锁' % self.name)

    def func2(self):
        B.acquire()
        print('%s 抢到了B锁' % self.name)
        A.acquire()
        print('%s 抢到了A锁' % self.name)
        A.release()
        print('%s 释放了A锁' % self.name)
        B.release()
        print('%s 释放了B锁' % self.name)

for i in range(10):
    obj = MyThread()
    obj.start()
 

总结

python多线程是否没用

# 是否有用需要看情况而定(程序的类型)
# IO密集型
	eg:四个任务  每个任务耗时10s
    	开设多进程没有太大的优势	42s+
        	遇到IO就需要切换 并且开设进程还需要申请内存空间和拷贝代码
        开设多线程有优势
			不需要消耗额外的资源   2s+
# 计算密集型
	eg:四个任务	 每个任务耗时10s
        计算密集型任务的特点是要进行大量的计算
        开设多进程可以利用多核优势	5s+
      	开设多线程无法利用多核优势   23s+
"""
多进程结合多线程
可以处理计算密集型与IO密集型
"""
"""IO密集型"""
# from multiprocessing import Process
# from threading import Thread
# import threading
# import os,time
# def work():
#     time.sleep(2)
#
#
# if __name__ == '__main__':
#     l=[]
#     print(os.cpu_count()) #本机为6核
#     start=time.time()
#     for i in range(400):
#         # p=Process(target=work) #耗时42.54s多,大部分时间耗费在创建进程上
#         p=Thread(target=work) #耗时2.08s多
#         l.append(p)
#         p.start()
#     for p in l:
#         p.join()
#     stop=time.time()
#     print('run time is %s' %(stop-start))


"""计算密集型"""
from multiprocessing import Process
from threading import Thread
import os,time
def work():
    res=0
    for i in range(100000000):
        res*=i
if __name__ == '__main__':
    l=[]
    print(os.cpu_count())  # 本机为6核
    start=time.time()
    for i in range(6):
        # p=Process(target=work) #耗时5.35s多
        p=Thread(target=work) #耗时23.37s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

总结:多线程是否无用要看程序的类型,完全可以进程与线程结合使用带到最快效率

IO密集型 :如:socket,爬虫,web  用多线程
计算密集型 :如 :金融分析(需要大量计算的)  用多进程

标签:解释器,name,self,死锁,线程,print,GIL
来源: https://www.cnblogs.com/jjjmhf50/p/15820815.html