28) Многопоточность в Python

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

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

1. приобретать ()

   Когда состояние блокировки разблокировано, вызов метода acqu () изменит состояние на заблокированное и вернет его. Однако, если состояние заблокировано, вызов acqu () блокируется до тех пор, пока метод release () не будет вызван каким-либо другим потоком.

2. релиз()

   Метод release () используется для установки состояния unlocked, т. Е. Для снятия блокировки. Он может быть вызван любым потоком, не обязательно тем, который получил блокировку.

Вот пример использования блокировок в ваших приложениях. Запустите ваш 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. Вы должны увидеть результат вроде этого:

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

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

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

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

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

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

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

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

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

Резюме

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