Способы обхода GIL для повышения производительности14.04.2024 08:30

Привет, Хабр!

Global Interpreter Lock в Питоне предотвращает одновременное выполнение нескольких потоков в одном процессе интерпретатора Python. Т.е даже на многоядерном процессоре многопоточные Python-приложения будут выполняться только в одном потоке за раз. Это было введено для некой потокобезопасности при работе с объектами Python, упрощая тем самым разработку на уровне интерпретатора.

На первый взгляд, GIL кажется разумным компромиссом для упрощения разработки. Однако, когда есть многоядерные процессоры и появляется необходимость в высокопроизводительных вычислениях GIL серьезно ограничивает возможности масштабирования и параллельную работу.

В этой статье рассмотрим способы обхода GIL и первый способ — использование многопроцессности вместо многопоточности.

Использование многопроцессности вместо многопоточности

Многопоточность оперирует потоками внутри одного процесса, деля память и состояние, тогда как многопроцессность запускает отдельные процессы, каждый со своей памятью и состоянием.

Реализовать многопроцессность можно с помощью либы multiprocessing. Она дает возможность каждому процессу работать с собственным интерпретатором Python и, соответственно, собственным GIL.Т. е каждый процесс может полноценно использовать отдельное ядро процессора, обходя ограничения, налагаемые GIL на многопоточное выполнение кода.

Основные функции multiprocessing

Блокировки используются для синхронизации доступа к ресурсам между разными процессами. Например, можно использовать Lock для гарантии того, что только один процесс может выполнять определенный участок кода одновременно:

from multiprocessing import Process, Lock

def printer(item, lock):
    lock.acquire()
    try:
        print(item)
    finally:
        lock.release()

if __name__ == '__main__':
    lock = Lock()
    items = ['тест1', 'тест2', 'тест3']
    for item in items:
        p = Process(target=printer, args=(item, lock))
        p.start()

Семафоры похожи на блокировки, но позволяют ограничить доступ к ресурсу не одним, а несколькими процессами одновременно:

from multiprocessing import Semaphore, Process

def worker(semaphore):
    with semaphore:
        # работа, требующая синхронизации
        print('Работает')

if __name__ == '__main__':
    semaphore = Semaphore(2)
    for _ in range(4):
        p = Process(target=worker, args=(semaphore,))
        p.start()

События позволяют процессам ожидать сигнал от других процессов для начала выполнения определенных действий:

from multiprocessing import Process, Event
import time

def waiter(event):
    print('Ожидание события')
    event.wait()
    print('Событие произошло')

if __name__ == '__main__':
    event = Event()

    for _ in range(3):
        p = Process(target=waiter, args=(event,))
        p.start()

    print('Главный процесс спит')
    time.sleep(3)
    event.set()

Очереди в multiprocessing позволяют безопасно обмениваться данными между процессами:

from multiprocessing import Process, Queue

def worker(queue):
    queue.put('Элемент от процесса')

if __name__ == '__main__':
    queue = Queue()
    p = Process(target=worker, args=(queue,))
    p.start()
    p.join()
    print(queue.get())

Асинхронное программирование

asyncio — это библиотека для написания конкурентного кода с использованием синтаксиса async/await, введенного в Python 3.5. Она служит базой для многих асинхронных фреймворков Python

В отличие от многопоточного исполнения, asyncio использует единственный поток и event loop для управления асинхронными операциями, что позволяет обходить ограничения, связанные с GIL.

Предположим, нужно собрать заголовки с нескольких веб-страниц. Будем юзатьaiohttp в качестве асинхронного HTTP-клиента для отправки запросов:

import asyncio
import aiohttp

async def fetch_title(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            html = await response.text()
            return html.split('')[0]

async def main(urls):
    tasks = [fetch_title(url) for url in urls]
    titles = await asyncio.gather(*tasks)
    for title in titles:
        print(title)

urls = [
    'https://example.com',
    'https://example.org',
    'https://example.net',
    # предположим, здесь список из тысячи URL
]

asyncio.run(main(urls))

Функция fetch_title асинхронно извлекает HTML-контент для заданного URL и возвращает содержимое тега