Python10天-冲刺---全局解释器锁

Python 的全局解释器锁（Global Interpreter Lock，简称 GIL）是为了简化 CPython 实现而引入的一种机制。GIL 在任何时刻只允许一个线程执行 Python 字节码，这意味着即使在多核处理器上，多个 Python 线程也不能真正并发执行 CPU 密集型任务。

为了避免 GIL 限制多线程性能，有几种常见的方法：

1. 使用多进程：利用 multiprocessing 模块，可以在不同的进程中运行代码，从而绕过 GIL 的限制。
2. 使用异步 I/O：对于 I/O 密集型任务，可以使用 asyncio 模块来提高效率。
3. 使用第三方库：某些第三方库（如 NumPy、Pandas）在内部使用 C 语言扩展，能够在释放 GIL 的情况下执行计算密集型操作。

下面是一些具体的示例代码，展示如何使用多进程和异步 I/O 来避免 GIL 的限制。

多进程示例

import multiprocessing

def worker(num):
    """线程要执行的任务"""
    result = num * num
    print(f'Worker process ID: {multiprocessing.current_process().pid}, Result: {result}')

if __name__ == '__main__':
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

异步 I/O 示例

import asyncio

async def fetch_data(url):
    print(f'Starting to fetch data from {url}')
    await asyncio.sleep(1)  # 模拟网络延迟
    print(f'Data fetched from {url}')

async def main():
    tasks = [
        asyncio.create_task(fetch_data('http://example.com')),
        asyncio.create_task(fetch_data('http://google.com'))
    ]
    await asyncio.gather(*tasks)

if __name__ == '__main__':
    asyncio.run(main())

结合多进程和异步 I/O

有时，结合多进程和异步 I/O 可以获得更好的性能。例如，可以使用多进程来处理 CPU 密集型任务，而在每个进程中使用异步 I/O 来处理 I/O 密集型任务。

import multiprocessing
import asyncio

async def fetch_data(url):
    print(f'Starting to fetch data from {url}')
    await asyncio.sleep(1)  # 模拟网络延迟
    print(f'Data fetched from {url}')

async def async_worker(urls):
    tasks = [fetch_data(url) for url in urls]
    await asyncio.gather(*tasks)

def worker(urls):
    asyncio.run(async_worker(urls))

if __name__ == '__main__':
    processes = []
    urls_list = [['http://example.com'], ['http://google.com']]
    for urls in urls_list:
        p = multiprocessing.Process(target=worker, args=(urls,))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

解释

1. 多进程示例：

   • 使用 multiprocessing.Process 创建多个进程，每个进程独立执行任务。
   • 每个进程有自己的 GIL，因此可以充分利用多核处理器的优势。

2. 异步 I/O 示例：

   • 使用 asyncio 库来管理异步任务。
   • asyncio.sleep 模拟网络延迟，实际应用中可以替换为真正的异步 I/O 操作。

3. 结合多进程和异步 I/O：

   • 使用多进程来处理 CPU 密集型任务。
   • 在每个进程中使用异步 I/O 来处理 I/O 密集型任务。

通过这些方法，你可以有效地避免 GIL 对多线程性能的影响，并充分利用现代硬件资源。