Многопоточность в Python на примере:изучаем GIL в Python

В любой момент времени философ должен либо есть, либо думать.

Более того, философ должен взять две соседние с ним вилки (то есть левую и правую вилки), прежде чем он сможет съесть спагетти. Проблема тупика возникает, когда все пять философов одновременно берут свои правильные вилки.

Поскольку у каждого из философов есть одна вилка, все они будут ждать, пока остальные опустят свои вилки. В результате никто из них не сможет есть спагетти.

Точно так же в параллельной системе взаимоблокировка возникает, когда разные потоки или процессы (философы) пытаются одновременно получить общие системные ресурсы (форки). В результате ни один из процессов не получает возможности выполниться, так как они ожидают другого ресурса, удерживаемого каким-то другим процессом.

Условия гонки

Состояние гонки — это нежелательное состояние программы, которое возникает, когда система одновременно выполняет две или более операций. Например, рассмотрим этот простой цикл for:

i=0; # a global variable
for x in range(100):
    print(i)
    i+=1;

Если вы создаете n количество потоков, которые запускают этот код одновременно, вы не можете определить значение i (которое разделяется потоками), когда программа завершает выполнение. Это связано с тем, что в реальной многопоточной среде потоки могут перекрываться, и значение i, которое было получено и изменено потоком, может измениться между ними, когда какой-либо другой поток обращается к нему.

Это два основных класса проблем, которые могут возникнуть в многопоточном или распределенном приложении Python. В следующем разделе вы узнаете, как решить эту проблему путем синхронизации потоков.

Синхронизация потоков

Для устранения условий гонки, взаимоблокировок и других проблем, связанных с потоками, модуль потоков предоставляет функцию Lock . объект. Идея состоит в том, что когда потоку требуется доступ к определенному ресурсу, он блокирует этот ресурс. Как только поток блокирует конкретный ресурс, никакой другой поток не может получить к нему доступ, пока блокировка не будет снята. В результате изменения ресурса будут атомарными, а условия гонки будут предотвращены.

Блокировка — это низкоуровневый примитив синхронизации, реализуемый __thread . модуль. В любой момент замок может находиться в одном из двух состояний:заблокирован или разблокирована. Он поддерживает два метода:

1. получить() Когда состояние блокировки разблокировано, вызов метода Acquis() изменит состояние на заблокированное и возврат. Тем не менее, если состояние заблокировано, вызов Acquis() блокируется до тех пор, пока какой-либо другой поток не вызовет метод release().
2. релиз() Метод release() используется для установки состояния разблокировано, т. е. для снятия блокировки. Его может вызывать любой поток, не обязательно тот, который получил блокировку.

Вот пример использования блокировок в ваших приложениях. Запустите IDLE и введите следующее:

import threading
lock = threading.Lock()

def first_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the first funcion')
        lock.release()

def second_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the second funcion')
        lock.release()

if __name__=="__main__":
    thread_one = threading.Thread(target=first_function)
    thread_two = threading.Thread(target=second_function)

    thread_one.start()
    thread_two.start()

    thread_one.join()
    thread_two.join()

Теперь нажмите F5. Вы должны увидеть такой вывод:

ОБЪЯСНЕНИЕ КОДА

1. Здесь вы просто создаете новую блокировку, вызывая метод threading.Lock(). заводская функция. Внутри Lock() возвращает экземпляр наиболее эффективного конкретного класса Lock, поддерживаемого платформой.
2. В первом операторе вы получаете блокировку, вызывая метод Acquire(). Когда блокировка предоставлена, вы печатаете «блокировка получена» к консоли. После завершения выполнения всего кода, который вы хотите запустить в потоке, вы снимаете блокировку, вызывая метод release().

Теория хороша, но как узнать, что замок действительно сработал? Если вы посмотрите на вывод, вы увидите, что каждый из операторов печати печатает ровно одну строку за раз. Вспомните, что в предыдущем примере выходные данные print были случайными, потому что несколько потоков обращались к методу print() одновременно. Здесь функция печати вызывается только после получения блокировки. Таким образом, результаты отображаются по одному и построчно.

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

1. RБлокировки
2. Семафоры
3. Условия
4. События и
5. Барьеры

Глобальная блокировка интерпретатора (и как с ней бороться)

Прежде чем углубляться в детали GIL Python, давайте определим несколько терминов, которые будут полезны для понимания следующего раздела:

1. Код, привязанный к ЦП:любой фрагмент кода, который будет непосредственно выполняться ЦП.
2. Код, связанный с вводом-выводом:это может быть любой код, который обращается к файловой системе через ОС.
3. CPython:эталонная реализация Python и может быть описан как интерпретатор, написанный на C и Python (язык программирования).

Что такое GIL в Python?

Глобальная блокировка интерпретатора (GIL) в python — это блокировка процесса или мьютекс, используемый при работе с процессами. Это гарантирует, что один поток может получить доступ к определенному ресурсу за раз, а также предотвращает одновременное использование объектов и байт-кодов. Это приносит пользу однопоточным программам в повышении производительности. GIL в Python очень прост и легок в реализации.

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

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

Например, предположим, что вы написали программу на Python, которая использует два потока для выполнения как операций ЦП, так и операций ввода-вывода. При выполнении этой программы происходит следующее:

1. Интерпретатор Python создает новый процесс и порождает потоки.
2. Когда поток 1 запустится, он сначала получит GIL и заблокирует его.
3. Если поток 2 хочет выполниться сейчас, ему придется дождаться освобождения GIL, даже если другой процессор свободен.
4. Теперь предположим, что поток-1 ожидает операции ввода-вывода. В это время он выпустит GIL, а поток-2 получит его.
5. После завершения операций ввода-вывода, если поток 1 хочет выполниться сейчас, ему снова придется ждать освобождения GIL потоком 2.

Из-за этого только один поток может получить доступ к интерпретатору в любой момент времени, а это означает, что будет только один поток, выполняющий код Python в данный момент времени.

Это нормально для одноядерного процессора, потому что он будет использовать квантование времени (см. первый раздел этого руководства) для обработки потоков. Однако в случае многоядерных процессоров функция, связанная с ЦП, выполняющаяся в нескольких потоках, окажет значительное влияние на эффективность программы, поскольку она фактически не будет использовать все доступные ядра одновременно.

Зачем был нужен GIL?

Сборщик мусора CPython использует эффективный метод управления памятью, известный как подсчет ссылок. Вот как это работает:каждый объект в python имеет счетчик ссылок, который увеличивается, когда ему присваивается новое имя переменной или добавляется в контейнер (например, кортежи, списки и т. д.). Точно так же счетчик ссылок уменьшается, когда ссылка выходит за пределы области действия или когда вызывается инструкция del. Когда счетчик ссылок на объект достигает 0, он удаляется сборщиком мусора, а выделенная память освобождается.

Но проблема в том, что переменная счетчика ссылок подвержена гонкам, как и любая другая глобальная переменная. Чтобы решить эту проблему, разработчики Python решили использовать глобальную блокировку интерпретатора. Другой вариант состоял в том, чтобы добавить блокировку к каждому объекту, что привело бы к взаимоблокировкам и увеличению накладных расходов на вызовыAcquire() и Release().

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

Обзор

• Python поддерживает 2 модуля многопоточности:
  1. __поток модуль:обеспечивает низкоуровневую реализацию многопоточности и устарел.
  2. модуль многопоточности :обеспечивает высокоуровневую реализацию многопоточности и является текущим стандартом.
• Чтобы создать цепочку с помощью модуля потоков, необходимо сделать следующее:
  1. Создайте класс, расширяющий Thread. класс.
  2. Переопределить его конструктор (__init__).
  3. Переопределить его run() метод.
  4. Создайте объект этого класса.
• Поток можно запустить, вызвав метод start(). метод.
• Функция join() можно использовать для блокировки других потоков до тех пор, пока этот поток (тот, для которого было вызвано объединение) не завершит выполнение.
• Состояние гонки возникает, когда несколько потоков одновременно обращаются к общему ресурсу или изменяют его.
• Этого можно избежать путем синхронизации потоков.
• Python поддерживает 6 способов синхронизации потоков:
  1. Замки
  2. RБлокировки
  3. Семафоры
  4. Условия
  5. События и
  6. Барьеры
• Блокировки позволяют только определенному потоку, получившему блокировку, войти в критическую секцию.
• У блокировки есть 2 основных метода:
  1. получить() :устанавливает состояние блокировки на заблокировано. При вызове для заблокированного объекта он блокируется до тех пор, пока ресурс не освободится.
  2. релиз() :устанавливает состояние блокировки на разблокировано. и возвращается. При вызове незаблокированного объекта возвращается значение false.
• Глобальная блокировка интерпретатора — это механизм, с помощью которого одновременно может выполняться только один процесс интерпретатора CPython.
• Он использовался для облегчения функции подсчета ссылок сборщика мусора CPythons.
• Чтобы создавать приложения Python с тяжелыми операциями, связанными с ЦП, следует использовать модуль многопроцессорности.