Шаг 226.
Python: сборник рецептов.
Конкурентность. Разбираемся с GIL (и перестаем волноваться по этому поводу)

    На этом шаге мы рассмотрим,как избежать глобальной блокировки интерпретатора.

Задача

    Вы слышали о глобальной блокировке интерпретатора (GIL) и волнуетесь, что она может повлиять на производительность вашей многопоточной программы.

Решение

    Хотя Python полностью поддерживает многопоточное программирование, части интепретатора, реализованные на C, не полностью потокобезопасны и не позволяют осуществлять полностью конкурентное выполнение. На самом деле интерпретатор защищен так называемой глобальной блокировкой интерпретатора (GIL), которая позволяет только одному потоку Python выполняться в любой конкретный момент времени. Наиболее заметный эффект GIL в том, что многопоточные программы на Python не могут полностью воспользоваться преимуществами многоядерных процессоров (тяжелые вычислительные задачи, использующие больше одного потока, работают только на одном CPU).

    Перед обсуждением распространенных способов обхода GIL важно подчеркнуть, что GIL влияет только на программы, сильно нагружающие CPU (то есть те, в которых вычисления доминируют). Если ваша программа в основном занимается вводом-выводом, что типично для сетевых коммуникаций, потоки часто являются разумным выбором, потому что они проводят большую часть времени в ожидании. На самом деле вы можете создать тысячи потоков Python без каких- либо проблем. Современные операционные системы легко справляются с запуском такого количества потоков, так что здесь вам просто не о чем волноваться.

    Для написания завязанных на CPU программ вам придется изучить природу выполняемых вычислений. Например, правильный выбор алгоритма может дать намного более заметный прирост скорости, чем попытки распараллелить неоптимальный алгоритм на потоки. Похожим образом, принимая во внимание то, что Python является интерпретируемым языком, вы можете получить значительный прирост производительности путем выноса чувствительного к скорости кода в модуль на языке C. Расширения типа NumPy также крайне эффективны для ускорения определенных вычислений с массивами данных. И последнее: вы можете исследовать альтернативные реализации, такие как PyPy, среди возможностей которой присутствует JIT-компилятор.

    Также стоит отметить, что потоки используются не только для повышения производительности. Зависящие от CPU программы могут использовать потоки для управления графическим интерфейсом, сетевым соединением, или предоставлять какой-то другой сервис. В этом случае GIL может представлять серьезную проблему, поскольку код, который удерживает ее слишком долго, будет вызывать раздражающие задержки в потоках, не связанных с обработкой данных с помощью CPU. На самом деле плохо написанное расширение на C может усугубить эту проблему, хотя часть, выполняющая вычисления, может работать быстрее.

    Сказав все это, перейдем к описанию приемов работы. Есть две типовые стратегии обхода ограничений GIL. Во-первых, если вы работаете полностью в Python, то можете использовать модуль multiprocessing, чтобы создать пул процессов и использовать его наподобие сопроцессора. Предположим, что у вас есть такой код на базе потоков: # Выполняет тяжелые вычисления (завязана на CPU)

def some_work(args):
    . . .
    return result

# Поток, который вызывает вышеприведенную функцию
def some_thread():
    while True:
        . . .
        r = some_work(args)
        . . .

    Вот как вы могли бы изменить код, чтобы использовать пул:

# Пул обработки (инициализацию см. ниже)
pool = None

# Выполняет тяжелые вычисления (завязана на CPU)
def some_work(args):
    . . .
    return result

# Поток, который вызывает вышеприведенную функцию
def some_thread():
    while True:
        . . .
        r = some_work(args)
        . . .

# Инициализация пула
if __name__ == '__main__':
    import multiprocessing

    pool = multiprocessing.Pool()

    Этот пример с пулом обходит GIL, используя хитрый трюк. Когда поток хочет выполнить тяжелые вычисления, он передает работу пулу. Пул, в свою очередь, передает работу отдельному интерпретатору Python, работающему в другом процессе. Пока поток ожидает результата, он освобождает GIL. Более того, по причине выполнения вычислений в отдельном интерпретаторе они более не связаны ограничениями GIL. На многоядерной системе вы обнаружите, что этот прием без проблем позволяет вам выжать максимум из всех CPU.

    Вторая стратегия для обхода GIL - сфокусироваться на программировании расширений на C. Общая идея в том, чтобы переместить тяжелые вычислительные задачи в модули С, работающие независимо от Python, и заставить код на C освобождать блокировку, когда он работает. Это делается путем помещения в код на C специальных макросов:

#include "Python.h"
. . .
PyObject *pyfunc(PyObject *self, PyObject *args) {
  . . .
  Py_BEGIN_ALLOW_THREADS
  // Threaded C code
  . . .
  Py_END_ALLOW_THREADS
  . . .
}

    Если вы используете другие инструменты для доступа к C, такие как библиотека ctypes или Cython, вам, возможно, не придется ничего делать. Например, ctypes по умолчанию освобождает GIL при вызове кода на C.

Обсуждение

    Многие программисты при встрече с проблемами производительности потоков обвиняют во всем GIL. Однако это близоруко и наивно. Приведем пример из реального мира: загадочные "зависания" в многопоточной сетевой программе могут быть вызваны совершенно другой причиной (например, подвисшим обращением к DNS), а не чем-то связанным с GIL. Короче говоря, вам нужно по-настоящему изучить свой код, чтобы понять, связана ли проблема с GIL. Повторимся: осознайте, что проблемы с GIL возникают в задачах, завязанных на тяжелой обработке на CPU, а не при работе с вводом-выводом.

    Если вы будете использовать пул процессов в качестве обходного пути, то вы должны знать, что вам придется применять сериализацию данных и коммуникацию с другим интерпретатором Python. Чтобы это работало, операция, которая должна быть выполнена, должна быть упакована в функцию, определенную через инструкцию def (то есть лямбды, замыкания, вызываемые объекты не подойдут) и аргументы функции, а возвращаемое значение должно быть совместимо с pickle. Также объем выполняемой работы должен быть достаточно большим, чтобы перекрыть оверхед на дополнительную коммуникацию.

    Другой тонкий аспект в том, что смешивание пулов процессов и пулов потоков - отличный способ взорвать себе голову. Если вы используете эти возможности вместе, часто лучше создать пул процессов как синглтон (паттерн "Одиночка") при запуске программы, перед созданием потоков. Потоки затем используют один и тот же пул процессов для всей тяжелой вычислительной работы.

    Для расширений на языке C очень важно поддерживать изоляцию от процесса интерпретатора Python. Если вы хотите переложить работу с Python на C, то убедитесь, что код на C работает независимо от Python. Это означает, что не надо использовать структуры данных Python и не надо вызывать API Python для работы с C. Еще один момент - убедитесь, что расширение на С выполняет достаточный объем работы, чтобы оправдать все усилия по его подключению. Намного лучше, когда расширение выполняет миллионы вычислений, нежели несколько небольших.

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

    На следующем шаге мы рассмотрим определение акторной задачи.




Предыдущий шаг Содержание Следующий шаг