全局解释器锁

最新推荐文章于 2025-09-26 20:09:52 发布

转载最新推荐文章于 2025-09-26 20:09:52 发布 · 169 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/cherish937426/p/11351829.html

文章标签：

#python #内存管理

本文详细探讨了Python中GIL（全局解释器锁）的作用及其对多线程的影响，分析了多线程在计算密集型和IO密集型任务中的表现，并介绍了递归锁、信号量、事件和队列等高级同步机制。

全局解释器锁

GIL(全局解释器锁)
在CPython解释器才有GIL的概念，不是python的特点
GIL也是一把互斥锁
将并发变成串行牺牲了效率但是提高了数据的安全
ps:
1.针对不同的数据应该使用不同的锁去处理
2.自己不要轻易的处理锁的问题哪怕你知道acquire和release
当业务逻辑稍微复杂的一点情况下极容易造成死锁
CPython中的GIL的存在是因为python的内存管理不是线程安全的

内存管理
引用计数:值与变量的绑定关系的个数
标记清除:当内存快要满的时候会自动停止程序的运行检测所有的变量与值的绑定关系
给没有绑定关系的值打上标记，最后一次性清除
分代回收:(垃圾回收机制也是需要消耗资源的，而正常一个程序的运行内部会使用到很多变量与值
并且有一部分类似于常量，减少垃圾回收消耗的时间，应该对变量与值的绑定关系做一个分类
) 新生代(5S)》》》青春代(10s)》》》老年代(20s)
垃圾回收机制扫描一定次数发现关系还在，会将该对关系移至下一代
随着代数的递增扫描频率是降低的

同一个进程下的多个线程能否同时运行
GIL类似于是加在解释器上面的一把锁

计算密集型

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) #耗时  4.732933044433594
        p=Thread(target=work) #耗时 22.83087730407715
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

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(4000):
        p=Process(target=work) #耗时9.001083612442017s多,大部分时间耗费在创建进程上
        # p=Thread(target=work) #耗时2.051966667175293s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

python的多线程到底有没有用需要看情况而定并且肯定是有用的

多进程+多线程配合使用

死锁

递归锁
可以被第一个抢到该锁的人多次的acquire和release，内部会有一个计数
acquire就是加
release就是减
当别人在抢这把锁的时候只要计数不为零永远也别想抢到

mutexA = mutexB = RLock()  # A B现在是同一把锁


class MyThread(Thread):
    def run(self):  # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s抢到了A锁'%self.name)  # self.name等价于current_thread().name
        mutexB.acquire()
        print('%s抢到了B锁'%self.name)
        mutexB.release()
        print('%s释放了B锁'%self.name)
        mutexA.release()
        print('%s释放了A锁'%self.name)

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

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

只要类加括号实例化对象无论传入的参数是否一样生成的对象肯定不一样单例模式除外

自己千万不要轻易的处理锁的问题

信号量

如果互斥锁是单个卫生间
那么信号量就是多个卫生间

from threading import Semaphore,Thread
import time
import random


sm = Semaphore(5)  # 造了一个含有五个的坑位的公共厕所

def task(name):
    sm.acquire()
    print('%s占了一个坑位'%name)
    time.sleep(random.randint(1,3))
    sm.release()

for i in range(40):
    t = Thread(target=task,args=(i,))
    t.start()

event事件

event事件
e = Event()

e.wait() 等待信号

e.set() 发送信号

from threading import Event,Thread
import time

# 先生成一个event对象
e = Event()


def light():
    print('红灯正亮着')
    time.sleep(3)
    e.set()  # 发信号
    print('绿灯亮了')

def car(name):
    print('%s正在等红灯'%name)
    e.wait()  # 等待信号
    print('%s加油门飙车了'%name)

t = Thread(target=light)
t.start()

for i in range(10):
    t = Thread(target=car,args=('伞兵%s'%i,))
    t.start()

线程queue

队列 Queue
堆栈 LifoQueue
优先级 P...Queue
只有一个参数是元组的形式
数字越小优先级越高

import queue
"""
同一个进程下的多个线程本来就是数据共享 为什么还要用队列

因为队列是管道+锁  使用队列你就不需要自己手动操作锁的问题 

因为锁操作的不好极容易产生死锁现象
"""



# q = queue.Queue()
# q.put('hahha')
# print(q.get())


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


# q = queue.PriorityQueue()
# # 数字越小 优先级越高
# q.put((10,'haha'))
# q.put((100,'hehehe'))
# q.put((0,'xxxx'))
# q.put((-10,'yyyy'))
# print(q.get())

转载于:https://www.cnblogs.com/cherish937426/p/11351829.html