python-GIL、死锁递归锁及线程补充

一、GIL介绍

GIL全称 Global Interpreter Lock ,中文解释为全局解释器锁。它并不是Python的特性,而是在实现python的主流Cpython解释器时所引入的一个概念,CIL本质上就是一把互斥锁,将并发运行变成串行,以此来控制同一时间内共享数据只能被一个任务所修改,从而保证数据的安全性。

注:每次执行python程序,都会产生一个独立的进程,进程里除了能看到的若干线程,还有看不见的解释器开启的垃圾回收等解释器级别的线程。

#1 所有数据都是共享的,这其中,代码作为一种数据也是被所有线程共享的(test.py的所有代码以及Cpython解释器的所有代码)
例如:test.py定义一个函数work(代码内容如下图),在进程内所有线程都能访问到work的代码,于是我们可以开启四个线程然后target都指向该代码,能访问到意味着就是可以执行。

#2 所有线程的任务,都需要将任务的代码当做参数传给解释器的代码去执行,即所有的线程要想运行自己的任务,首先需要解决的是能够访问到解释器的代码。

多个线程先访问到解释器的代码,去拿去执行权限,然后将自己target的代码拿给解释器去执行,解释器的代码是对所有线程都共享的,这个时候就存在一个问题,垃圾回收线程也可以去访问解释器代码,对于同一个数据,可能线程1去修改它的数据的同时 垃圾回收对他执行的是回收操作,这个时候就会导致很多无法预料的bug。GIL加锁处理,就是保证解释器同一时间内只能执行一个任务的代码。这就导致了同一个进程下的线程无法实现并行,不能很好的利用cpu的多核机制,但是还是可以实现并行的。(如果想实现并行只能开启多个进程)

二、GIL与Lock的区别

GIL保护的是解释器级别的数据,但是用户自己的数据需要自己加锁处理。

from threading import Thread,Lock
import time

mutex=Lock()
n=100
def task():
    global n
    with mutex:
        temp=n
        time.sleep(0.1)
        n=temp-1

if __name__ == ‘__main__‘:
    l=[]
    for i in range(100):
        t=Thread(target=task)
        l.append(t)
        t.start()

    for t in l:
        t.join()
    print(n)

test

通过自定义互斥锁,每个线程除了要抢到GIL锁之外还要抢到自定义的锁,否则即使抢到了GIL也没有用,这就充分保证了数据的安全性。

三、GIL与多线程

既然有了GIL的存在,一个进程中同一时刻只有一个线程能够被执行,无法利用cpu的多核机制,和多进程一比,是不是多进程反而更占优势了呢。

那多核机制有什么好处呢?

cpu是用来做计算的,多核,意味多个cpu去完成计算功能,提升计算性能,但是cpu一旦遇到 I/O操作,那么多核对I/O就没有什么帮助了。

#计算操作
from multiprocessing import Process
import os,time
from threading import Thread

def work():
    res=0
    for i in range(100000000):
        res+=i

if __name__ == ‘__main__‘:
    print(os.cpu_count())

    p_l =[]
    start = time.time()
    for i in range(4):
        p = Process(target=work)#5.057471036911011
        # p = Thread(target=work)#18.38089609146118
        p.start()
        p_l.append(p)

    for j in p_l:
        j.join()
    print(‘time is %s‘%(time.time()-start))

计算操作

#io操作
from threading import Thread
from multiprocessing import Process
import time

def work():
    time.sleep(4)

if __name__ == ‘__main__‘:
    p_l = []
    start = time.time()
    for i in range(4):
        p = Process(target=work)#4.281008243560791
        # p = Thread(target=work)#4.002274751663208
        p_l.append(p)
        p.start()
    for j in p_l:
        j.join()
    print(p_l)
    print(‘time is %s‘ % (time.time() - start))

I/O操作

总结:

  多线程用于I/O密集型,如socket,爬虫,web等

  多进程用于计算密集型,如金融分析等。

四、死锁与递归锁

死锁:两个或两个以上的进程或者线程在执行过程中,因为真多资源二造成的互相等待现象,若无外力的作用,题目都将一直处于阻塞状态,这些互相等待的进程或者线程就被称为死锁。

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print(‘\033[41m%s 拿到A锁\033[0m‘ %self.name)

        mutexB.acquire()
        print(‘\033[42m%s 拿到B锁\033[0m‘ %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print(‘\033[43m%s 拿到B锁\033[0m‘ %self.name)
        time.sleep(2)

        mutexA.acquire()
        print(‘\033[44m%s 拿到A锁\033[0m‘ %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == ‘__main__‘:
    for i in range(10):
        t=MyThread()
        t.start()

‘‘‘
Thread-1 拿到A锁
Thread-1 拿到B锁
Thread-1 拿到B锁
Thread-2 拿到A锁
然后就卡住,死锁了
‘‘‘

test

解决方法,使用递归锁(RLock)

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

from threading import Thread,Lock,RLock
import time

mutexB=mutexA=RLock()
#一个线程拿到锁,counter加1,该线程内又碰到加锁的情况,则counter继续加1,这期间所有其他线程都只能等待,等待该线程释放所有锁,即counter递减到0为止

class Mythead(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print(‘%s 抢到A锁‘ %self.name)
        mutexB.acquire()
        print(‘%s 抢到B锁‘ %self.name)
        mutexB.release()
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print(‘%s 抢到了B锁‘ %self.name)
        time.sleep(2)
        mutexA.acquire()
        print(‘%s 抢到了A锁‘ %self.name)
        mutexA.release()
        mutexB.release()

if __name__ == ‘__main__‘:
    for i in range(100):
        t=Mythead()
        t.start()

test

五、信号量Semaphore

Semaphore管理一个内置的计数器,
每当调用acquire()时内置计数器-1;
调用release() 时内置计数器+1;
计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。

from threading import Thread,Semaphore
import time,random
sm=Semaphore(5)#最大连接数为5

def task(name):
    sm.acquire()
    print(‘%s 正在上厕所‘ %name)
    time.sleep(random.randint(1,3))
    sm.release()

if __name__ == ‘__main__‘:
    for i in range(20):
        t=Thread(target=task,args=(‘路人%s‘ %i,))
        t.start()

test

六、Event

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时就需要用到threading中的Event对象。对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

from threading import Thread,Event
import time

event=Event()

def light():
    print(‘红灯正亮着‘)
    time.sleep(3)
    event.set() #绿灯亮

def car(name):
    print(‘车%s正在等绿灯‘ %name)
    event.wait() #等灯绿
    print(‘车%s通行‘ %name)

if __name__ == ‘__main__‘:
    # 红绿灯
    t1=Thread(target=light)
    t1.start()
    # 车
    for i in range(10):
        t=Thread(target=car,args=(i,))
        t.start()

test

七、queue补充

线程的queue和进程一样,这里补充一下queue.LifoQueue()和queue.PriorityQueue()优先级

queue.LifoQueue() 后进先出---->堆栈

q=queue.LifoQueue(3)
q.put(1)
q.put(2)
q.put(3)
print(q.get())#3
print(q.get())#2
print(q.get())#1

queue.LifoQueue

queue.PriorityQueue() 设置优先级别,数字越小,优先级别越高

q=queue.PriorityQueue(3) #优先级,优先级用数字表示,数字越小优先级越高
q.put((10,‘a‘))
q.put((-1,‘b‘))
q.put((100,‘c‘))
print(q.get())#(-1, ‘b‘)
print(q.get())#(10, ‘a‘)
print(q.get())#(100, ‘c‘)

PriorityQueue

原文地址:https://www.cnblogs.com/mangM/p/9606642.html

时间: 2024-11-07 23:21:32

python-GIL、死锁递归锁及线程补充的相关文章

Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池

目录 Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池 1.昨日回顾 2.死锁现象与递归锁 2.1死锁现象 2.2递归锁 3.信号量 4.GIL全局解释器锁 4.1背景 4.2为什么加锁 5.GIL与Lock锁的区别 6.验证计算密集型IO密集型的效率 6.1 IO密集型 6.2 计算密集型 7.多线程实现socket通信 7.1服务端 7.2客户端 8.进程池,线程池 Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池 1.昨日回顾 #生产者消

并发&并行 同步&异步 GIL 任务 同步锁 死锁 递归锁

# 并发&并行 同步&异步 GIL 任务 同步锁 死锁 递归锁 # 并发:是指系统具有处理多个任务(动作)的能力 # 并行:是指系统具有 同时 处理多个任务(动作)的能力 # 同步:当进程执行到一个IO(等待外部数据)的时候,需要等待外部数据接收完 # 异步:当进程执行到一个IO(等待外部数据)的时候,不需要等待外部数据接收完,还可以做其它的处理 # GIL: 全局解释器锁 在python中,无论你启多少个线程,你有多少个cpu,python在执行的时候在同一时刻只请允许一个线程运行 #

Python之路-python(paramiko,进程和线程的区别,GIL全局解释器锁,线程,进程)

一.paramiko 二.进程.与线程区别 三.python GIL全局解释器锁 四.线程 语法 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件 queue队列 生产者消费者模型 Queue队列 一.paramiko 用于远程连接并执行简单的命令 使用用户名密码连接: 1 import paramiko 2 3 # 创建SSH对象 4 ssh = paramiko.SSHClient() 5 # 允许连接不在know_hosts文件中的主机 6 ssh.set

python 线程(创建2种方式,守护进程,锁,死锁,递归锁,GIL锁,其他方式)

###############总结############ 线程创建的2种方式(重点) 进程:资源分配单位    线程:cpu执行单位(实体) 线程的创建和销毁的开销特别小 线程之间资源共享,是同一个进程中的资源共享,会涉及到安全问题,所以需要加锁解决 锁:牺牲了效率,保证了数据安全(重点) 死锁现象:出现在嵌套的时候,双方互相抢对方已经拿到的锁,导致双方互相等待(重点) 递归锁: 解决了死锁现象(重点) rlock 首先本身就是个互斥锁,维护了一个计数器,每次acquire+1,release

线程的创建 验证线程之间共享数据 守护线程 线程进程效率对比 锁 死锁 递归锁

线程(from threading import Thread):CPU调度的最小单位 线程的两种创建方式:方式一: 1 from threading import Thread 2 def f1(i): 3 print(i) 4 if __name__ == '__main__': 5 for i in range(10): 6 t = Thread(target=f1,args=(i,)) 7 t.start() 8 print('主线程') 方式二: 1 from threading im

并发编程8 线程的创建&验证线程之间数据共享&守护线程&线程进程效率对比&锁(死锁/递归锁)

1.线程理论以及线程的两种创建方法 2.线程之间是数据共享的与join方法 3.多线程和多进程的效率对比 4.数据共享的补充线程开启太快 5.线程锁 互斥锁 同步锁 6.死锁现象和递归锁 7.守护线程和守护进程的对比 8.补充 9.GIL锁&GIL锁与线程锁的区别 10.GIL锁补充 11.信号量 时间补充说明 原文地址:https://www.cnblogs.com/studybrother/p/10269278.html

python第三十七天,GIL全局解释器锁*****,线程池与进程池 同步异步,阻塞与非阻塞,异步回调

GIL全局解释器锁 1.什么是GIL 官方解释:'''In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe

多线程——GIL\信号量\递归锁

互斥锁 1.什么是GIL(global interpreter lock)? GIL是一个互斥锁:保证数据的安全(牺牲效率来获取数据的安全),阻止同一个进程内的多线=线程同时执行(不能并行但是能实现并发)2.为什么会有GIL? 由于cpython解释器的内存管理不是线程安全的(垃圾回收机制的存在) 同一进程想的多线程不能实现并行但是可以实现并发,不同进程下可以实现并行 问题:Python多线程是不是就没有用: 举个例子: 四个任务:计算密集任务,每个任务10s 单核情况下: 多线程好点,消耗资源

同步锁 死锁 递归锁

多线程 同步锁(互斥锁) 解决什么问题? 同步锁解决什么问题? 多个线程操作同一个数据,可能会发生数据错乱的问题,因为一个线程拿到数据后,还没来得及对数据进行操作,cpu就有可能去执行另外一个线程,另外一个线程拿到的则是之前线程没有处理完的数据,如下 import threading import time count=20 def zx(): global count print(count) time.sleep(0.001) count-=1 t_list=[] for t in rang