GIL全局解释锁

• 官方对于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. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)

结论：在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势

• 普遍使用的都是Cpython解释器

一、GIL锁与普通互斥锁的区别

• 当子线程中过程中遇到IO阻塞时，GIL锁会放开并切换另一个至线程，因为线程之间的切换是非常快的，即使只是在我们看来只是阻塞了0.1秒但是已经有很多线程已经开始了,就导致许多线程在同一时间对一个数据进行修改，就出现了与预期不符的结果

from threading import Thread, Lock
import time

money = 100


def run():
    global money
    temp = money
    time.sleep(0.1)
    money = temp - 1


def main():
    t_list = []
    for i in range(50):
        t = Thread(target=run)
        t.start()
        t_list.append(t)

    for t in t_list:
        t.join()
    print(money)


if __name__ == '__main__':
    # 50 个子线程同时对数据进行修改，都返回99
    main()  # 99

• 当没有阻塞时,就会默认上GIL锁，同一时刻只允许一个线程开始，谁先开始谁先处理数据

from threading import Thread, Lock
import time

money = 100


def run():
    global money
    temp = money
    money = temp - 1


def main():
    t_list = []
    for i in range(50):
        t = Thread(target=run)
        t.start()
        t_list.append(t)

    for t in t_list:
        t.join()
    print(money)


if __name__ == '__main__':
    main()  # 50

• 自动加锁并解锁
• 子线程启动 ， 后先去抢 GIL 锁 ， 进入 IO 自动释放 GIL 锁 ， 但是自己加的锁还没解开 ，其他线程资源能抢到 GIL 锁，但是抢不到互斥锁
• 最终 GIL 回到 互斥锁的那个进程上，处理数据

from threading import Thread, Lock
import time

money = 100
lock = Lock()


def run():
    lock.acquire()
    global money
    time.sleep(0.1)
    temp = money
    money = temp - 1
    lock.release()


def main():
    t_list = []
    for i in range(50):
        t = Thread(target=run)
        t.start()
        t_list.append(t)

    for t in t_list:
        t.join()
    print(money)


if __name__ == '__main__':
    main()  # 50

二、GIL导致多线程无法利用多核优势

[1] Cpython 解释器中 GIL

• 在Cpython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时进行
  • 同一个进程下的多个线程无法利用多线程并发这一优势吗？
  • Python的多线程是不是一点用都没有？
• 因为在Cpython中的内存管理不是线程安全的
  • PS:内存管理（垃圾回收机制）
    • 应用计数
    • 标记清除
    • 分代回收

[2]Python的多线程是不是一点用都没有？

• 同一个进程下的多线程无法利用多核优势，是不是就没用了
• 多线程是否有用要看情况
  • 单核
    • 四个任务（IO密集型/计算密集型）
  • 多核
    • 四个任务（IO密集型/计算密集型）

（1）计算密集型

一直处在计算运行中

• 每个任务都需要 10s
  • 单核
    • 多进程：额外消耗资源
    • 多线程：减少开销
  • 多核
    • 多进程：总耗时 10s
    • 多线程：总耗时 40s+

（2）IO密集型

存在多个 IO 阻塞切换操作

• 每个任务都需要 10s
  • 多核
    • 多进程：相对浪费资源
    • 多线程：更加节省资源

[3]小结

• 计算是消耗CPU的：
  • 代码执行，算术，for都是计算
• IO不消耗CPU：
  • 打开文件，写入文件，网络操作都是IO
  • 如果遇到IO，该线程会释放CPU的执行权限，CPU转而去执行别的线程
• 由于python有GIL锁，开启多条线程，统一时刻，只能有一条线程在执行
• 如果是计算密集型，开了多线程，同一时刻，只有一个线程在执行
• 多核CPU，就会浪费多核优势
• 如果是计算密集型，我们希望，多个核(CPU),都干活，同一个进程下绕不过gil锁
• 所以我们开启多进程，GIL锁只能锁住某个进程中得线程，开启多个进程，就能利用多核优势
• IO密集型---》只要遇到IO，就会释放CPU执行权限
• 进程内开了多个IO线程，线程多半都在等待，开启多进程是不能提高效率的，反而开启进程很耗费资源，所以使用多线程即可

（1）计算密集型任务(多进程)

• 计算密集型任务主要是指需要大量的CPU计算资源的任务，其中包括执行代码、进行算术运算、循环等。
  • 在这种情况下，使用多线程并没有太大的优势。
  • 由于Python具有全局解释器锁（Global Interpreter Lock，GIL），在同一时刻只能有一条线程执行代码，这意味着在多线程的情况下，同一时刻只有一个线程在执行计算密集型任务。
• 但是，如果使用多进程，则可以充分利用多核CPU的优势。
  • 每个进程都有自己独立的GIL锁，因此多个进程可以同时执行计算密集型任务，充分发挥多核CPU的能力。
  • 通过开启多个进程，我们可以将计算密集的任务分配给每个进程，让每个进程都独自执行任务，从而提高整体的计算效率。

（2）IO密集型任务(多线程)

• IO密集型任务主要是指涉及大量输入输出操作（如打开文件、写入文件、网络操作等）的任务。
  • 在这种情况下，线程往往会因为等待IO操作而释放CPU执行权限，不会造成太多的CPU资源浪费。
  • 因此，使用多线程能够更好地处理IO密集型任务，避免了频繁切换进程的开销。
• 当我们在一个进程中开启多个IO密集型线程时，大部分线程都处于等待状态，开启多个进程却不能提高效率，反而会消耗更多的系统资源。
  • 因此，在IO密集型任务中，使用多线程即可满足需求，无需开启多个进程。

（3）总结

• 计算密集型任务使用多进程可以充分利用多核CPU的优势，而IO密集型任务使用多线程能够更好地处理IO操作，避免频繁的进程切换开销。
  • 根据任务的特性选择合适的并发方式可以有效提高任务的执行效率。

三、GIL特点总结

• 1.GIL 不是python的特点而是Cpython解释器的特点
• 2.GIL 保证解释器级别的数据的安全
• 3.GIL会导致同一个进程下的多个线程的无法同时进行即无法利用多核优势
• 4.针对不同的数据还是需要加不同的锁处理
• 5.解释型语言的通病：同一个进程下的多个线程无法利用多核优势