.. currentmodule:: asyncio

Synchronization Primitives

asyncio synchronization primitives are designed to be similar to those of the :mod:`threading` module with two important caveats:

• asyncio primitives are not thread-safe, therefore they should not be used for OS thread synchronization (use :mod:`threading` for that);
• methods of these synchronization primitives do not accept the timeout argument; use the :func:`asyncio.wait_for` function to perform operations with timeouts.

asyncio has the following basic synchronization primitives:

• :class:`Lock`
• :class:`Event`
• :class:`Condition`
• :class:`Semaphore`
• :class:`BoundedSemaphore`

Lock

Implements a mutex lock for asyncio tasks. Not thread-safe.

An asyncio lock can be used to guarantee exclusive access to a shared resource.

The preferred way to use a Lock is an :keyword:`async with` statement:

lock = asyncio.Lock()

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

which is equivalent to:

lock = asyncio.Lock()

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

.. coroutinemethod:: acquire()

 Acquire the lock.

 This method waits until the lock is *unlocked*, sets it to
 *locked* and returns ``True``.

 When more than one coroutine is blocked in :meth:`acquire`
 waiting for the lock to be unlocked, only one coroutine
 eventually proceeds.

 Acquiring a lock is *fair*: the coroutine that proceeds will be
 the first coroutine that started waiting on the lock.

.. method:: release()

 Release the lock.

 When the lock is *locked*, reset it to *unlocked* and return.

 If the lock is *unlocked*, a :exc:`RuntimeError` is raised.

.. method:: locked()

 Return ``True`` if the lock is *locked*.

Event

An event object. Not thread-safe.

An asyncio event can be used to notify multiple asyncio tasks that some event has happened.

An Event object manages an internal flag that can be set to true with the :meth:`set` method and reset to false with the :meth:`clear` method. The :meth:`wait` method blocks until the flag is set to true. The flag is set to false initially.

Example:

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())

.. coroutinemethod:: wait()

 Wait until the event is set.

 If the event is set, return ``True`` immediately.
 Otherwise block until another task calls :meth:`set`.

.. method:: set()

 Set the event.

 All tasks waiting for event to be set will be immediately
 awakened.

.. method:: clear()

 Clear (unset) the event.

 Tasks awaiting on :meth:`wait` will now block until the
 :meth:`set` method is called again.

.. method:: is_set()

 Return ``True`` if the event is set.

Condition

Semaphore

BoundedSemaphore

.. deprecated:: 3.7

 Acquiring a lock using ``await lock`` or ``yield from lock`` and/or
 :keyword:`with` statement (``with await lock``, ``with (yield from
 lock)``) is deprecated. Use ``async with lock`` instead.

此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。

如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。