GIL及相关总结

最新推荐文章于 2024-09-11 08:51:43 发布

给我起把狙

最新推荐文章于 2024-09-11 08:51:43 发布

阅读量845

点赞数 24

文章标签： python

本文链接：https://blog.csdn.net/weixin_48232453/article/details/141964431

版权

进程VS线程VS核心

1. 进程是大任务

进程代表的是一个运行中的程序，它是一个“大任务”。进程是操作系统分配资源的基本单位，包括内存、文件句柄等。
每个进程都有自己的独立内存空间，进程之间是相互隔离的，不共享内存。

2. 多线程处理小任务

一个进程可以包含一个或多个线程。每个线程可以理解为这个大任务中的一个“小任务”，负责执行某一部分工作。
线程共享进程的内存和资源，这使得它们能够高效地进行协同工作。

3. 核心处理线程

核心（Core） 是实际执行线程任务的物理单元。每个核心可以运行多个线程，但在同一时刻只能真正执行一个线程的代码。
当一个进程创建了多个线程时，这些线程可以分布在多个核心上执行，从而加快任务的处理速度。

4. 核心与线程的关系

可以将核心处理多个线程理解为：一个大任务（进程）被分解成多个小任务（线程），然后这些线程分布到不同的核心上执行。
操作系统通过线程调度器来管理哪个核心执行哪些线程，它会动态地将线程分配给可用的核心，从而实现并行处理。

5. 总结

进程是一个大的任务，包含了所有的资源和上下文。
线程是进程中处理具体任务的小单元，多个线程协作来完成整个进程的工作。
核心是实际执行这些线程的硬件单元，每个核心可以执行多个线程。

线程安全

线程安全 是指在多线程环境下，代码能正确、预期地执行，而不因为多个线程同时访问或修改共享数据而产生错误。

具体解释：

多线程问题：在多线程环境中，多个线程可能同时访问和修改同一块内存（即共享数据）。如果没有适当的控制，这些线程可能会相互干扰，导致数据损坏或程序崩溃。
线程安全代码：为了避免这些问题，线程安全的代码会确保在任何时候，只有一个线程能访问或修改共享数据。常见的方法包括使用锁（如 Lock）、条件变量（Condition）或其他同步机制。

举例说明：

假设你有一个银行账户，两个线程 T1 和 T2 试图同时对账户余额进行操作：

T1 试图从账户中取出 100 元。
T2 试图存入 50 元。

如果没有线程安全措施，可能会发生这样的情况：

T1 读取账户余额为 500 元。
T2 也读取账户余额为 500 元。
T1 执行取款操作，余额更新为 400 元。
T2 执行存款操作，余额更新为 550 元。

最终余额应为 450 元，但因为两个线程同时操作，导致结果不正确。线程安全的代码会确保在任意时刻只有一个线程可以修改账户余额，避免这种错误。

垃圾回收机制

垃圾回收机制（Garbage Collection，GC） 是一种自动管理内存的技术，用于释放程序中不再使用的对象或内存空间，以防止内存泄漏和优化内存使用。

具体解释：

对象生命周期：在程序中，通常会创建许多对象或变量，当这些对象不再被需要时，它们占用的内存应该被释放，以便其他部分的程序可以利用这些内存。
手动 vs. 自动内存管理：在一些编程语言中（如 C、C++），程序员必须手动释放不再使用的内存。这很容易导致内存泄漏或其他内存管理问题。而在 Python 等高级语言中，垃圾回收机制会自动处理这些对象的内存释放。

Python 中的垃圾回收：

引用计数：Python 的主要垃圾回收机制是基于引用计数的。当一个对象的引用计数变为 0 时，表示没有任何变量或对象引用它，它就会被自动删除。
循环引用处理：如果两个或多个对象互相引用但都不再被程序其他部分使用，Python 的垃圾回收器会定期检查和清理这些循环引用对象。

举例说明：

python复制代码a = [1, 2, 3]
b = a
a = None  # a 不再引用 [1, 2, 3]，但 b 仍然引用它

b = None  # 现在没有变量引用 [1, 2, 3] 这个列表对象，垃圾回收器会将其删除

在上面的例子中，Python 的垃圾回收器会在 a 和 b 都不再引用那个列表时自动释放它的内存。

python GIL机制

GIL（Global Interpreter Lock，全局解释器锁） 是 Python 解释器（特别是 CPython）中的一个机制，用来确保在任意时刻只有一个线程在执行 Python 字节码。这意味着，即使你的计算机有多个处理器或 CPU 核心，Python 的多线程程序在任何时刻也只能由一个线程在执行 Python 代码。

为什么需要 GIL？

Python 的内存管理器（比如垃圾回收机制）不是线程安全的。如果多个线程同时访问和修改共享数据，可能会导致数据不一致或程序崩溃。GIL 的作用就是通过锁定全局解释器，防止多个线程同时执行 Python 代码，从而避免这些问题。

GIL 是如何工作的？

当你在 Python 中启动一个线程时，这个线程必须先获取 GIL 锁，然后才能执行 Python 字节码。一旦线程持有 GIL，它就可以执行代码。但在某些条件下（如线程运行时间过长或线程主动释放 GIL），GIL 会被释放，以允许其他线程获取并执行。

GIL 的影响

多线程 CPU 绑定任务的性能瓶颈：对于计算密集型任务（如数学计算、图像处理等），GIL 会限制 Python 程序的性能，即使你启动了多个线程，它们实际上也无法并行地使用多个 CPU 核心。
I/O 密集型任务的表现：对于 I/O 密集型任务（如文件读写、网络请求等），GIL 的影响较小。因为 I/O 操作往往需要等待（比如等数据返回），此时线程会释放 GIL，让其他线程执行。因此，在处理 I/O 密集型任务时，多线程还是有利的。

GIL 的例子

假设你有一个多线程程序，每个线程都在执行大量的数学计算：

python复制代码import threading

def compute():
    for i in range(1000000):
        pass  # 模拟计算密集型任务

threads = []
for _ in range(4):  # 假设我们启动4个线程
    thread = threading.Thread(target=compute)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

即使你的 CPU 有 4 个核心，以上代码也无法真正实现 4 个线程并行计算，因为 GIL 的存在，每次只有一个线程在执行 Python 字节码。因此，运行时间不会因为多线程而显著减少。

如何应对 GIL 的限制？

多进程：使用 multiprocessing 模块来代替 threading 模块。每个 Python 进程有自己独立的 GIL，这意味着不同进程可以在不同的 CPU 核心上并行执行。

python复制代码from multiprocessing import Process

def compute():
    for i in range(1000000):
        pass

processes = []
for _ in range(4):  # 启动4个进程
    process = Process(target=compute)
    processes.append(process)
    process.start()

for process in processes:
    process.join()

使用 C 扩展或其他语言：如果计算非常密集，可以使用 C 扩展或其他支持多线程并行的语言进行关键部分的实现。C 扩展可以释放 GIL，让其他线程在执行 Python 代码时同时进行计算。
选择没有 GIL 的 Python 解释器：一些 Python 解释器（如 Jython、IronPython）没有 GIL，因此可以更好地处理多线程并行任务。