threading — Параллелизм на основе потоков

Данные локальные для потока

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

mydata = threading.local()
mydata.x = 1

Значения экземпляра будут разными для разных потоков.

class threading.local

Класс, представляющий данные локальные для потока.

Более подробную информацию и обширные примеры можно найти в документации модуля _threading_local.

Объекты потока

Класс Thread представляет собой активность, выполняемую в отдельном потоке управления. Есть два способа указать активность: передать вызываемый объект в конструктор или переопределить метод run() в подклассе. Никакие другие методы (кроме конструктора) не должны переопределяться в подклассе. Другими словами, переопределяйте только методы __init__() и run() этого класса.

После создания объекта потока его активность должна быть запущена вызовом метода start() потока. Это вызывает метод run() в отдельном потоке управления.

После запуска активности потока поток считается «активным». Он перестаёт быть активным, когда метод run() завершается — либо нормально, либо сгенерировав необработанное исключение. Метод is_alive() проверяет, является ли поток активным.

Другие потоки могут вызвать метод join() потока. Это блокирует вызывающий поток, пока поток, метод join() которого вызывается, не завершится.

Поток имеет имя. Имя можно передать в конструктор и прочитать или изменить через атрибут name.

Если метод run() генерирует исключение, вызывается threading.excepthook() для его обработки. По умолчанию threading.excepthook() игнорирует исключение SystemExit.

Поток может быть помечен как «демон-поток». Значение этого флага заключается в том, что вся программа Python завершается, когда остаются только демон-потоки. Начальное значение наследуется от создающего потока. Флаг можно установить с помощью свойства daemon или аргумента конструктора daemon.

Существует объект «главный поток»; это соответствует начальному потоку управления в программе Python. Он не является демон-потоком.

Возможна ситуация создания «объектов потоков-заглушек». Это объекты потоков, соответствующие «внешним потокам», которые являются потоками управления, запущенными за пределами модуля threading, например, непосредственно из кода C. Объекты потоков-заглушек имеют ограниченную функциональность; они всегда считаются активными и демон-потоками и не могут быть join()ed. Они никогда не удаляются, так как невозможно обнаружить завершение внешних потоков.

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

Этот конструктор всегда должен вызываться с ключевыми аргументами. Аргументы:

group должен быть None; зарезервирован для будущего расширения, когда реализован класс ThreadGroup.

target — вызываемый объект, который будет вызван методом run(). По умолчанию None, то есть ничего не вызывается.

name — имя потока. По умолчанию генерируется уникальное имя в формате «Поток-N», где N — небольшое десятичное число, или «Поток-N (цель)», где «цель» — target.__name__ если указан аргумент target.

args — кортеж аргументов для вызова целевого объекта. По умолчанию ().

kwargs — словарь ключевых аргументов для вызова целевого объекта. По умолчанию {}.

Если не None, daemon явно задаёт, является ли поток демоническим. Если None (по умолчанию), свойство daemon наследуется от текущего потока.

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

Изменено в версии 3.10: Используется имя target, если аргумент name опущен.

Изменено в версии 3.3: Добавлен аргумент daemon.

start()

Запустить активность потока.

Он должен вызываться не более одного раза для каждого объекта потока. Он организует вызов метода run() объекта в отдельном потоке управления.

Этот метод генерирует исключение RuntimeError, если вызывается более одного раза для одного и того же объекта потока.

run()

Метод, представляющий активность потока.

Вы можете переопределить этот метод в подклассе. Стандартный метод run() вызывает вызываемый объект, переданный в конструктор объекта как аргумент target, если таковой имеется, с позиционными и ключевыми аргументами из аргументов args и kwargs соответственно.

join(timeout=None)

Подождать завершения потока. Этот метод блокирует вызывающий поток до тех пор, пока поток, метод join() которого вызывается, не завершится — либо нормально, либо из-за необработанного исключения — или пока не произойдёт заданный таймаут.

Когда аргумент timeout присутствует и не None, он должен быть числом с плавающей точкой, определяющим таймаут операции в секундах (или долях секунды). Так как join() всегда возвращает None, вам необходимо вызвать is_alive() после join(), чтобы определить, произошёл ли таймаут — если поток всё ещё жив, вызов join() истек по таймауту.

Когда аргумент timeout не указан или None, операция будет блокироваться до завершения потока.

Поток можно join() много раз.

join() генерирует исключение RuntimeError, если попытка объединения текущего потока, так как это приведет к тупику. Также ошибка вызывать join() поток до его запуска, попытка сделать это вызывает то же самое исключение.

name

Строка, используемая только для идентификации. Она не имеет семантики. Несколько потоков могут иметь одинаковое имя. Начальное имя устанавливается конструктором.

getName()

setName()

Устаревший API для получения/установки name; используйте его непосредственно как свойство вместо него.

Устарело начиная с версии 3.10.

ident

Идентификатор потока или None если поток ещё не запущен. Это целое число, отличное от нуля. См. функцию get_ident(). Идентификаторы потоков могут быть переиспользованы, когда поток завершается, а создаётся другой. Идентификатор доступен даже после завершения потока.

native_id

Идентификатор потока (TID) этого потока, присвоенный операционной системой (ядром). Это целое неотрицательное число или None если поток ещё не запущен. См. функцию get_native_id(). Это значение может использоваться для уникальной идентификации этого конкретного потока в системе (до завершения потока, после чего значение может быть переиспользовано ОС).

Примечание

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

Доступность: Требуется функция get_native_id().

Введено в версии 3.8.

is_alive()

Возвращает, жив ли поток.

Этот метод возвращает True сразу перед началом метода run() и до завершения метода run(). Модульная функция enumerate() возвращает список всех живых потоков.

daemon

Булево значение, указывающее, является ли этот поток демоническим потоком (True) или нет (False). Это должно быть установлено до вызова start(), в противном случае генерируется RuntimeError. Его начальное значение наследуется от создающего потока; основной поток не является демоническим потоком, и поэтому все потоки, созданные в главном потоке, по умолчанию имеют daemon = False.

Вся программа Python завершается, когда не остаётся живых не-демонических потоков.

isDaemon()

setDaemon()

Устаревший API для получения/установки daemon; используйте его непосредственно как свойство вместо него.

Устарело начиная с версии 3.10.

Объекты блокировок

Примитивная блокировка — это синхронизирующий инструмент, не принадлежащий конкретной нити во время блокировки. В Python в настоящее время это базовый синхронизирующий инструмент, реализованный напрямую модулем расширения _thread.

Примитивная блокировка находится в одном из двух состояний: «заблокирована» или «разблокирована». Она создается в состоянии «разблокирована». Она имеет два основных метода, acquire() и release(). Когда состояние «разблокировано», acquire() изменяет состояние на «заблокировано» и возвращает значение немедленно. Когда состояние «заблокировано», acquire() блокируется, пока вызов release() в другой нити не изменит его на «разблокировано», после чего вызов acquire() сбрасывает его на «заблокировано» и возвращает значение. Метод release() должен вызываться только в заблокированном состоянии; он изменяет состояние на «разблокировано» и возвращает значение немедленно. Если попытка разблокировать разблокированную блокировку, будет выброшено исключение RuntimeError.

Блокировки также поддерживают протокол управления контекстом протокол управления контекстом.

Когда более одной нити заблокированы в acquire(), ожидая, пока состояние не станет «разблокировано», только одна нить продолжает выполнение, когда вызов release() сбрасывает состояние на «разблокировано»; какая нить будет продолжена, не определено и может отличаться в разных реализациях.

Все методы выполняются атомарно.

class threading.Lock

Класс, реализующий примитивные объекты блокировки. После того, как нить получила блокировку, последующие попытки получить её блокируются, пока она не будет освобождена; любую нить может её освободить.

Обратите внимание, что Lock фактически является функцией-фабрикой, которая возвращает экземпляр самого эффективного варианта конкретного класса Lock, поддерживаемого платформой.

acquire(blocking=True, timeout=- 1)

Получить блокировку, блокирующим или неблокирующим способом.

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

При вызове с аргументом blocking установленным в False, не блокировать. Если вызов с blocking установленным в True заблокирует, вернуть False немедленно; в противном случае установить блокировку в заблокированное состояние и вернуть True.

При вызове с плавающим аргументом timeout установленным в положительное значение, заблокироваться на самое большое количество секунд, указанное в timeout, и до тех пор, пока блокировка не может быть получена. Аргумент timeout со значением -1 указывает неограниченное ожидание. Запрещается указывать timeout, когда blocking равно False.

Значение возврата равно True если блокировка получена успешно, False если нет (например, если timeout истек).

Изменено в версии 3.2: Параметр timeout является новым.

Изменено в версии 3.2: Получение блокировки теперь может быть прервано сигналами на POSIX, если реализация потоков в основе поддерживает это.

release()

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

Когда блокировка заблокирована, она устанавливается в состояние «разблокировано» и возвращается. Если другие нити заблокированы, ожидая, пока блокировка станет разблокированной, разрешается продолжить работе ровно одной из них.

Если блокировка разблокирована, то генерируется исключение RuntimeError.

Значение возврата отсутствует.

locked()

Возвращает True если блокировка получена.

Объекты перевключных блокировок

Перевключная блокировка — это синхронизирующий инструмент, который может быть получен многократно одной и той же нитью. Внутренне она использует понятия «владеющая нить» и «уровень рекурсии» в дополнение к состоянию заблокировано/разблокировано, используемому примитивными блокировками. В заблокированном состоянии какая-то нить владеет блокировкой; в разблокированном состоянии ни одна нить не владеет ею.

Чтобы заблокировать блокировку, нить вызывает метод acquire(); она возвращает значение, как только нить владеет блокировкой. Чтобы разблокировать блокировку, нить вызывает метод release(). Вызовы acquire()/release() могут быть вложенными; только финальный вызов release() (вызов release() самого внешнего вложенного вызова) сбрасывает блокировку в состояние «разблокировано» и позволяет другой нити, заблокированной в acquire(), продолжить работу.

Перевключные блокировки также поддерживают протокол управления контекстом протокол управления контекстом.

class threading.RLock

Этот класс реализует объекты перевключных блокировок. Перевключная блокировка должна быть освобождена той нитью, которая её получила. После того, как нить получила перевключную блокировку, та же нить может получить её снова без блокировки; нить должна освободить её один раз для каждого раза, когда она её получила.

Обратите внимание, что RLock фактически является функцией-фабрикой, которая возвращает экземпляр самого эффективного варианта конкретного класса RLock, поддерживаемого платформой.

acquire(blocking=True, timeout=- 1)

Получить блокировку, блокирующим или неблокирующим способом.

При вызове без аргументов: если эта нить уже владеет блокировкой, увеличить уровень рекурсии на один и вернуть значение немедленно. В противном случае, если другая нить владеет блокировкой, заблокироваться до тех пор, пока блокировка не будет разблокирована. После разблокировки блокировки (ни одна нить не владеет ей), получить владение, установить уровень рекурсии на один и вернуть значение. Если более одной нити заблокированы в ожидании разблокировки, только одна сможет получить владение блокировкой. В этом случае возвращаемое значение отсутствует.

При вызове с аргументом blocking установленным в True, сделать то же самое, что и при вызове без аргументов, и вернуть True.

При вызове с аргументом blocking установленным в False, не блокировать. Если вызов без аргументов заблокирует, вернуть False немедленно; в противном случае сделать то же самое, что и при вызове без аргументов, и вернуть True.

При вызове с плавающим аргументом timeout установленным в положительное значение, заблокироваться на самое большое количество секунд, указанное в timeout, и до тех пор, пока блокировка не может быть получена. Возвратить True если блокировка получена, False если время ожидания истекло.

Изменено в версии 3.2: Параметр timeout является новым.

release()

Освободить блокировку, уменьшив уровень рекурсии. Если после уменьшения он равен нулю, установить блокировку в состояние «разблокировано» (ни одна нить не владеет ей) и, если другие нити заблокированы, ожидая, пока блокировка станет разблокированной, разрешить продолжить работе ровно одной из них. Если после уменьшения уровень рекурсии всё ещё не равен нулю, блокировка остаётся заблокированной и владеет ею вызывающая нить.

Вызывать этот метод только когда вызывающая нить владеет блокировкой. RuntimeError вызывается, если этот метод вызывается, когда блокировка разблокирована.

Значение возврата отсутствует.

Объекты условий

Переменная условия всегда связана с каким-либо замком; его можно передать или он будет создан по умолчанию. Передача его полезна, когда несколько переменных условия должны использовать один и тот же замок. Замок является частью объекта условия: вам не нужно отслеживать его отдельно.

Переменная условия подчиняется протоколу управления контекстом: использование оператора with приобретает связанный замок на время заключённого блока. Методы acquire() и release() также вызывают соответствующие методы связанного замка.

Другие методы должны вызываться, удерживая связанный замок. Метод wait() освобождает замок, а затем блокируется до тех пор, пока другой поток не разбудит его, вызвав notify() или notify_all(). После пробуждения wait() повторно приобретает замок и возвращается. Также можно указать таймаут.

Метод notify() разбуживает один из потоков, ожидающих переменной условия, если такие потоки есть. Метод notify_all() разбуживает все потоки, ожидающие переменной условия.

Примечание: методы notify() и notify_all() не освобождают замок; это означает, что разбуженный поток или потоки не вернутся из вызова wait() немедленно, а только тогда, когда поток, вызвавший notify() или notify_all(), в конечном итоге уступит владение замком.

Типичный стиль программирования, использующий переменные условия, использует замок для синхронизации доступа к некоторому общему состоянию; потоки, заинтересованные в определённом изменении состояния, вызывают wait() многократно, пока не увидят желаемое состояние, в то время как потоки, изменяющие состояние, вызывают notify() или notify_all(), когда они изменяют состояние таким образом, что это состояние может быть желаемым состоянием для одного из ожидающих потоков. Например, следующий код — это обобщённая ситуация «производитель-потребитель» с неограниченной ёмкостью буфера:

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

Цикл while проверки условия приложения необходим, потому что wait() может вернуться после произвольно долгого времени, и условие, которое спровоцировало вызов notify(), может больше не выполняться. Это присуще многопоточному программированию. Метод wait_for() можно использовать для автоматизации проверки условия и облегчения вычисления таймаутов:

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

При выборе между notify() и notify_all() следует учитывать, может ли одно изменение состояния быть интересным только для одного или нескольких ожидающих потоков. Например, в типичной ситуации «производитель-потребитель» добавление одного элемента в буфер требует только разбудить один поток потребителя.

class threading.Condition(lock=None)

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

Если аргумент lock задан и не None, он должен быть объектом Lock или RLock, и он используется в качестве базового замка. В противном случае создаётся новый объект RLock и используется в качестве базового замка.

Изменено в версии 3.3: изменено из фабричной функции в класс.

acquire(*args)

Приобретение базового замка. Этот метод вызывает соответствующий метод базового замка; возвращаемое значение — это то, что возвращает этот метод.

release()

Освобождение базового замка. Этот метод вызывает соответствующий метод базового замка; возвращаемое значение отсутствует.

wait(timeout=None)

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

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

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

Если базовый замок — RLock, он не освобождается с помощью метода release(), так как это может не разблокировать замок, когда он был приобретён несколько раз рекурсивно. Вместо этого используется внутренний интерфейс класса RLock, который действительно разблокирует его, даже если он был приобретён рекурсивно несколько раз. Затем используется другой внутренний интерфейс для восстановления уровня рекурсии при повторном приобретении замка.

Возвращаемое значение — True до тех пор, пока не истечёт заданный таймаут, в этом случае — False.

Изменено в версии 3.2: Ранее метод всегда возвращал None.

wait_for(predicate, timeout=None)

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

Этот вспомогательный метод может вызывать wait() многократно, пока предикат не будет удовлетворён или не произойдёт истечение таймаута. Возвращаемое значение — последнее возвращаемое значение предиката и будет оцениваться как False в случае истечения таймаута.

Без учёта таймаута вызов этого метода примерно эквивалентен написанию:

while not predicate():
    cv.wait()

Поэтому применяются те же правила, что и для wait(): замок должен быть удерживаемым при вызове и повторно приобретается при возврате. Предикат оценивается при удерживаемом замке.

Новое в версии 3.2.

notify(n=1)

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

Этот метод разбуживает не более n из ожидающих потоков переменной условия; это бесполезно, если ждущих потоков нет.

Текущая реализация разбуживает ровно n потоков, если ждёт хотя бы n потоков. Однако полагаться на это поведение небезопасно. Будущая оптимизированная реализация может изредка разбудить больше, чем n потоков.

Примечание: разбуженный поток не возвращается из вызова wait() до тех пор, пока не сможет повторно приобрести замок. Так как notify() не освобождает замок, его вызывающий поток должен.

notify_all()

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

Метод notifyAll — устаревший псевдоним для этого метода.

Объекты семафоров

Это одна из старейших примитивов синхронизации в истории компьютерной науки, изобретённая голландским компьютерным учёным Эдсгером В. Дейкстрой (он использовал названия P() и V() вместо acquire() и release()).

Семафор управляет внутренней переменной-счётчиком, которая уменьшается на 1 при каждом вызове acquire() и увеличивается на 1 при каждом вызове release(). Счётчик никогда не может стать меньше нуля; когда acquire() обнаруживает, что он равен нулю, он блокируется, ожидая, пока другая нить не вызовет release().

Семафоры также поддерживают протокол управления контекстом.

class threading.Semaphore(value=1)

Этот класс реализует объекты семафоров. Семафор управляет атомарным счётчиком, представляющим количество вызовов release() минус количество вызовов acquire(), плюс начальное значение. Метод acquire() блокируется при необходимости, пока не сможет вернуть значение без понижения счётчика до отрицательного. Если не указано, value по умолчанию равно 1.

Необязательный аргумент задаёт начальное значение для внутреннего счётчика; по умолчанию он равен 1. Если заданное значение меньше 0, возникает исключение ValueError.

Изменено в версии 3.3: изменено с функции-конструктора на класс.

acquire(blocking=True, timeout=None)

Получить семафор.

При вызове без аргументов:

• Если внутренний счётчик больше нуля при входе, уменьшите его на 1 и верните True немедленно.
• Если внутренний счётчик равен нулю при входе, заблокируйтесь до пробуждения вызовом release(). После пробуждения (и счётчик больше 0), уменьшите счётчик на 1 и верните True. Ровно одна нить будет разбужена каждым вызовом release(). Порядок пробуждения нитей не гарантируется.

При вызове с blocking, установленным в False, не блокировать. Если вызов без аргумента заблокирует, верните False немедленно; в противном случае сделайте то же самое, что и при вызове без аргументов, и верните True.

При вызове с timeout, отличным от None, он будет заблокирован не более чем на timeout секунд. Если acquire не выполнится успешно в течение этого интервала, верните False. В противном случае верните True.

Изменено в версии 3.2: Параметр timeout новый.

release(n=1)

Освободить семафор, увеличив внутренний счётчик на n. Когда он был равен нулю при входе, и другие нити ожидают, пока он не станет больше нуля, разбудите n из них.

Изменено в версии 3.9: Добавлен параметр n для одновременного разбуждения нескольких ожидающих нитей.

class threading.BoundedSemaphore(value=1)

Класс, реализующий ограниченные объекты семафоров. Ограниченный семафор проверяет, чтобы его текущее значение не превышало его начального значения. Если это произойдёт, возникает исключение ValueError. В большинстве ситуаций семафоры используются для защиты ресурсов с ограниченной ёмкостью. Если семафор освобождается слишком много раз, это признак ошибки. Если не указано, value по умолчанию равно 1.

Изменено в версии 3.3: изменено с функции-конструктора на класс.

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

with pool_sema:
    conn = connectdb()
    try:
        # ... use connection ...
    finally:
        conn.close()

Объекты событий

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

Объект события управляет внутренней меткой, которая может быть установлена в истинное значение методом set() и сброшена в ложное методом clear(). Метод wait() блокируется до тех пор, пока метка не станет истинной.

class threading.Event

Класс, реализующий объекты событий. Событие управляет флагом, который может быть установлен в истинное значение методом set() и сброшен в ложное значение методом clear(). Метод wait() блокируется до тех пор, пока флаг не станет истинным. Флаг изначально ложный.

Изменено в версии 3.3: изменено с функции-конструктора на класс.

is_set()

Возвращает True тогда и только тогда, когда внутренний флаг равен true.

Метод isSet — устаревший псевдоним для этого метода.

set()

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

clear()

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

wait(timeout=None)

Заблокироваться до тех пор, пока внутренний флаг не станет истинным. Если внутренний флаг равен true при входе, вернитесь немедленно. В противном случае, заблокируйтесь до тех пор, пока другая нить не вызовет set() для установки флага в истинное значение, или пока не наступит заданный таймаут.

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

Этот метод возвращает True тогда и только тогда, когда внутренний флаг был установлен в истинное значение, либо до вызова wait, либо после его начала, поэтому он всегда возвращает True за исключением случая, когда задан таймаут, и операция истекает.

Изменено в версии 3.1: Ранее метод всегда возвращал None.

Объекты таймеров

Этот класс представляет собой действие, которое должно быть выполнено только после истечения определенного промежутка времени — таймер. Timer является подклассом Thread и, как таковой, также служит примером создания пользовательских потоков.

Таймеры запускаются, как и потоки, вызовом их метода start(). Таймер можно остановить (до начала его действия) вызовом метода cancel(). Промежуток времени, который таймер будет ждать перед выполнением своего действия, может не совпадать точно с заданным пользователем промежутком.

Например:

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

class threading.Timer(interval, function, args=None, kwargs=None)

Создайте таймер, который выполнит функцию function с аргументами args и ключевыми аргументами kwargs через interval секунд. Если args равно None (по умолчанию), будет использоваться пустой список. Если kwargs равно None (по умолчанию), будет использоваться пустой словарь.

Изменено в версии 3.3: изменено с фабричной функции на класс.

cancel()

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

Объекты барьеров

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

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

В качестве примера, вот простой способ синхронизировать поток клиента и сервера:

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

class threading.Barrier(parties, action=None, timeout=None)

Создайте объект барьера для parties потоков. Если задана функция action, она вызывается одним из потоков, когда они освобождаются. timeout – значение таймаута по умолчанию, если оно не указано для метода wait().

wait(timeout=None)

Пройти барьер. Когда все потоки, участвующие в барьере, вызовут эту функцию, все они одновременно освобождаются. Если указан timeout, он используется вместо любого, указанного в конструкторе класса.

Возвращаемое значение – целое число в диапазоне от 0 до parties – 1, разное для каждого потока. Это может быть использовано для выбора потока, который выполнит некоторые специальные операции обслуживания, например:

i = barrier.wait()
if i == 0:
    # Only one thread needs to print this
    print("passed the barrier")

Если в конструктор был передан параметр action, то один из потоков его вызовет перед освобождением. Если при этом произойдет ошибка, барьер переходит в состояние разрыва.

Если вызов истечет по времени, барьер переходит в состояние разрыва.

Этот метод может вызвать исключение BrokenBarrierError, если барьер сломан или сброшен, пока поток ожидает.

reset()

Вернуть барьер в исходное, пустое состояние. Любые потоки, ожидающие его, получат исключение BrokenBarrierError.

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

abort()

Перевести барьер в состояние разрыва. Это приводит к тому, что любые активные или будущие вызовы wait() завершаются с ошибкой BrokenBarrierError. Используйте это, например, если один из потоков должен прерваться, чтобы избежать тупика приложения.

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

parties

Число потоков, необходимых для прохождения барьера.

n_waiting

Число потоков, которые в данный момент ожидают в барьере.

broken

Булево значение, которое равно True , если барьер находится в состоянии разрыва.

exception threading.BrokenBarrierError

Это исключение, подкласс RuntimeError, возникает, когда объект Barrier сбрасывается или нарушается.

Использование блокировок, условий и семафоров в операторе with

Все объекты, предоставляемые этим модулем, которые имеют методы acquire() и release(), могут быть использованы в качестве управляющих контекстов для оператора with. Метод acquire() будет вызван при входе в блок, а release() будет вызван при выходе из блока. Следовательно, следующий фрагмент:

with some_lock:
    # do something...

эквивалентен:

some_lock.acquire()
try:
    # do something...
finally:
    some_lock.release()

В настоящее время объекты Lock, RLock, Condition, Semaphore и BoundedSemaphore могут быть использованы в качестве управляющих контекстов оператора with.