Примитивы синхронизации

Реализует мьютекс-блокировку для задач asyncio. Не потокобезопасна.

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

Предпочтительный способ использования блокировки — оператор async with:

lock = asyncio.Lock()

# ... later
async with lock:
    # access shared state

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

lock = asyncio.Lock()

# ... later
await lock.acquire()
try:
    # access shared state
finally:
    lock.release()

coroutine acquire()

Захватить блокировку.

Этот метод ожидает, пока блокировка не будет разблокирована, устанавливает её в заблокированное состояние и возвращает True.

Когда более одной корутины заблокированы в acquire() в ожидании разблокировки блокировки, только одна корутина в конечном итоге продолжает выполнение.

Получение блокировки честное: корутина, которая продолжит работу, будет первой корутиной, которая начала ожидание блокировки.

release()

Освободить блокировку.

Когда блокировка заблокирована, она сбрасывается в разблокированное состояние и возвращается значение.

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

locked()

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

Объект события. Не потокобезопасен.

Объект события asyncio может использоваться для уведомления нескольких задач asyncio о том, что произошло некоторое событие.

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

Пример:

async def waiter(event):
    print('waiting for it ...')
    await event.wait()
    print('... got it!')

async def main():
    # Create an Event object.
    event = asyncio.Event()

    # Spawn a Task to wait until 'event' is set.
    waiter_task = asyncio.create_task(waiter(event))

    # Sleep for 1 second and set the event.
    await asyncio.sleep(1)
    event.set()

    # Wait until the waiter task is finished.
    await waiter_task

asyncio.run(main())

coroutine wait()

Ожидать, пока событие не будет установлено.

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

set()

Установить событие.

Все задачи, ожидающие установки события, будут немедленно разбужены.

clear()

Сбросить (убрать установку) события.

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

is_set()

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

Объект условия. Не потокобезопасен.

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

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

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

Предпочтительный способ использования условия — оператор async with:

cond = asyncio.Condition()

# ... later
async with cond:
    await cond.wait()

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

cond = asyncio.Condition()

# ... later
await cond.acquire()
try:
    await cond.wait()
finally:
    cond.release()

coroutine acquire()

Захватить базовую блокировку.

Этот метод ожидает, пока базовая блокировка не будет разблокирована, устанавливает её в заблокированное состояние и возвращает True.

notify(n=1)

Разбудить не более n задач (по умолчанию 1), ожидающих этого условия. Метод ничего не делает, если задач нет.

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

locked()

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

notify_all()

Разбудить все задачи, ожидающие этого условия.

Этот метод действует как notify(), но разбуживает все ожидающие задачи.

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

release()

Освободить базовую блокировку.

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

coroutine wait()

Ожидать уведомления.

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

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

coroutine wait_for(predicate)

Ожидать, пока предикат не станет истинным.

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

Объект семафора. Не потокобезопасен.

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

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

Предпочтительный способ использования семафора — оператор async with:

sem = asyncio.Semaphore(10)

# ... later
async with sem:
    # work with shared resource

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

sem = asyncio.Semaphore(10)

# ... later
await sem.acquire()
try:
    # work with shared resource
finally:
    sem.release()

coroutine acquire()

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

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

locked()

Возвращает True если семафор не может быть получен немедленно.

release()

Освободить семафор, увеличив внутренний счётчик на единицу. Может разбудить задачу, ожидающую получения семафора.

В отличие от BoundedSemaphore, Semaphore позволяет делать больше release() вызовов, чем acquire() вызовов.

Объект ограниченного семафора. Не потокобезопасен.

Ограниченный семафор — это версия Semaphore, которая генерирует исключение ValueError в release(), если она увеличивает внутренний счётчик выше начального значения value.