Python协程(asyncio)（四）同步原语

Python实用教程_spiritx的博客-CSDN博客

asyncio 同步原语被设计为与 threading 模块的类似，但有两个关键注意事项:
asyncio 原语不是线程安全的，因此它们不应被用于 OS 线程同步 (而应当使用 threading)；
这些同步原语的方法不接受 timeout 参数；请使用 asyncio.wait_for() 函数来执行带有超时的操作。

Lock

class asyncio.Lock

实现一个用于 asyncio 任务的互斥锁。 非线程安全。
asyncio 锁可被用来保证对共享资源的独占访问。
使用 Lock 的推荐方式是通过 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()

主要方法和属性：

事件

class asyncio.Event

事件对象。 该对象不是线程安全的。
asyncio 事件可被用来通知多个 asyncio 任务已经有事件发生。
Event 对象会管理一个内部旗标，可通过 set() 方法将其设为 true 并通过 clear() 方法将其重设为 false。 wait() 方法会阻塞直至该旗标被设为 true。 该旗标初始时会被设为 false。

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

主要方法和属性：

Condition

class asyncio.Condition(lock=None)
条件对象。 该对象不是线程安全的。
asyncio 条件原语可被任务用于等待某个事件发生，然后获取对共享资源的独占访问。
在本质上，Condition 对象合并了 Event 和 Lock 的功能。 多个 Condition 对象有可能共享一个 Lock，这允许关注于共享资源的特定状态的不同任务实现对共享资源的协同独占访问。
可选的 lock 参数必须为 Lock 对象或 None。 在后一种情况下会自动创建一个新的 Lock 对象。
使用 Condition 的推荐方式是通过 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()

主要方法和属性：

Semaphore

class asyncio.Semaphore(value=1)
信号量对象。 该对象不是线程安全的。
信号量会管理一个内部计数器，该计数器会随每次 acquire() 调用递减并随每次 release() 调用递增。 计数器的值永远不会降到零以下；当 acquire() 发现其值为零时，它将保持阻塞直到有某个任务调用了 release()。
可选的 value 参数用来为内部计数器赋初始值 (默认值为 1)。 如果给定的值小于 0 则会引发 ValueError。
使用 Semaphore 的推荐方式是通过 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()

主要方法和属性：

BoundedSemaphore

class asyncio.BoundedSemaphore(value=1)
绑定的信号量对象。 该对象不是线程安全的。

BoundedSemaphore 是特殊版本的 Semaphore，如果在 release() 中内部计数器值增加到初始 value 以上它将引发一个 ValueError。

Barrier

class asyncio.Barrier(parties)

栅栏是一个简单的同步原语，它允许阻塞，直到有大量任务在等待它。任务可以在wait（）方法上等待，并且会被阻塞，直到指定数量的任务最终达到等待的数量parties。此时，所有等待的任务都将同时解除锁定。

栅栏最好通过async with来使用。

async def example_barrier():
   # barrier with 3 parties
   b = asyncio.Barrier(3)
 
   # create 2 new waiting tasks
   asyncio.create_task(b.wait())
   asyncio.create_task(b.wait())
 
   await asyncio.sleep(0)
   print(b)
 
   # The third .wait() call passes the barrier
   await b.wait()
   print(b)
   print("barrier passed")
 
   await asyncio.sleep(0)
   print(b)
 
asyncio.run(example_barrier())

主要方法和属性：

...
async with barrier as position:
   if position == 0:
      # Only one task prints this
      print('End of *draining phase*')