源码解读Python中Event事件的使用

import asyncio
from asyncio import Event

async def task(event: Event):
    # 如果 event 内部的标志位是 False，会陷入阻塞
    print(f"陷入阻塞，因为标志位 = {event.is_set()}")
    await event.wait()
    print(f"解除阻塞，因为标志位 = {event.is_set()}")

async def main():
    event = Event()
    # 任务开始执行
    asyncio.create_task(task(event))
    await asyncio.sleep(3)
    # task 内部的 event.wait() 会陷入阻塞
    # 3 秒将标志设置为 True
    print("将 event 内部的标志位设置为 True")
    event.set()

asyncio.run(main())
"""
陷入阻塞，因为标志位 = False
将 event 内部的标志位设置为 True
解除阻塞，因为标志位 = True
"""

import time
import threading
from threading import Event

def task():
    # 如果 event 内部的标志位是 False，会陷入阻塞
    print(f"陷入阻塞，因为标志位 = {event.is_set()}")
    event.wait()
    print(f"解除阻塞，因为标志位 = {event.is_set()}")

def main():
    time.sleep(3)
    print("将 event 内部的标志位设置为 True")
    event.set()

event = Event()
t1 = threading.Thread(target=task)
t2 = threading.Thread(target=main)
t1.start()
t2.start()
"""
陷入阻塞，因为标志位 = False
将 event 内部的标志位设置为 True
解除阻塞，因为标志位 = True
"""

class Event:

    def __init__(self):
        # 条件对象，所以事件对象其实是基于条件对象的一个封装
        self._cond = Condition(Lock())
        # 标志位，初始为 False
        self._flag = False

    def is_set(self):
        # 标志位是否被设置
        return self._flag

    isSet = is_set

    def set(self):
        # 修改共享变量时需要加锁保护
        with self._cond:
            # 设置标志位，并唤醒所有阻塞线程
            self._flag = True
            self._cond.notify_all()

    def clear(self):
        # 将标志位设置为 False
        with self._cond:
            self._flag = False

    def wait(self, timeout=None):
        # 阻塞等待，但支持超时时间
        with self._cond:
            signaled = self._flag
            if not signaled:
                signaled = self._cond.wait(timeout)
            return signaled