import asyncio

# 获取当前事件循环
loop = asyncio.get_running_loop()  # Python 3.7+ 推荐

# 运行一个协程直到完成
async def main():
    print("Hello")

asyncio.run(main())  # 自动创建、运行、关闭事件循环

# 定义协程
async def fetch_data():
    await asyncio.sleep(1)
    return {"data": 42}

# 调用协程会返回协程对象，不会立即执行
coro = fetch_data()
print(type(coro))  # <class 'coroutine'>

# 运行协程的三种方式
# 方式1：asyncio.run()（最常用）
result = asyncio.run(fetch_data())

# 方式2：await（在另一个协程中）
async def main():
    result = await fetch_data()

# 方式3：create_task（并发执行，见下文）

async def demo():
    # ✅ 正确：await 协程
    result = await fetch_data()
    
    # ❌ 错误：await 普通函数
    # await time.sleep(1)  # TypeError
    
    # ✅ 正确：await asyncio 提供的可等待对象
    await asyncio.sleep(1)

async def task_func(name, delay):
    await asyncio.sleep(delay)
    print(f"Task {name} done")
    return name

async def main():
    # 创建任务（立即开始调度，但还未执行）
    task1 = asyncio.create_task(task_func("A", 2))
    task2 = asyncio.create_task(task_func("B", 1))
    
    # 等待任务完成，同时获取返回值
    result1 = await task1
    result2 = await task2
    print(f"Results: {result1}, {result2}")
    # 输出顺序：Task B done, Task A done
    # 总耗时约2秒，而非3秒

asyncio.run(main())

# 很少直接使用，了解即可
future = asyncio.Future()
async def set_result():
    await asyncio.sleep(1)
    future.set_result("Done")

asyncio.create_task(set_result())
result = await future  # 等待结果

import asyncio

async def fetch(url):
    await asyncio.sleep(1)
    return f"Data from {url}"

# 方式1：gather - 最常用，保持顺序
async def use_gather():
    results = await asyncio.gather(
        fetch("url1"),
        fetch("url2"),
        fetch("url3"),
    )
    print(results)  # 顺序与传入一致

# 方式2：wait - 更灵活的并发控制
async def use_wait():
    tasks = [fetch(f"url{i}") for i in range(3)]
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
    for task in done:
        print(task.result())

# 方式3：as_completed - 谁先完成先处理谁
async def use_as_completed():
    tasks = [fetch(f"url{i}") for i in range(3)]
    for coro in asyncio.as_completed(tasks):
        result = await coro
        print(result)  # 顺序不固定

async def slow_operation():
    await asyncio.sleep(10)
    return "Done"

async def with_timeout():
    try:
        # 等待最多5秒
        result = await asyncio.wait_for(slow_operation(), timeout=5)
    except asyncio.TimeoutError:
        print("操作超时了！")
        # 可选：取消任务
        # task.cancel()

async def cancellable_task():
    try:
        while True:
            await asyncio.sleep(1)
            print("Working...")
    except asyncio.CancelledError:
        print("任务被取消，执行清理工作")
        # 清理资源
        raise  # 重新抛出，让上层处理

async def main():
    task = asyncio.create_task(cancellable_task())
    await asyncio.sleep(3)
    task.cancel()  # 发送取消信号
    
    try:
        await task
    except asyncio.CancelledError:
        print("任务已取消")

# Lock - 互斥锁
async def use_lock():
    lock = asyncio.Lock()
    async with lock:
        # 临界区，同一时间只有一个协程能进入
        await asyncio.sleep(1)

# Queue - 生产者-消费者模式（必用！）
async def producer_consumer():
    queue = asyncio.Queue(maxsize=10)
    
    async def producer():
        for i in range(5):
            await queue.put(f"item {i}")
            await asyncio.sleep(0.1)
        await queue.put(None)  # 终止信号
    
    async def consumer():
        while True:
            item = await queue.get()
            if item is None:
                break
            print(f"Processing {item}")
            queue.task_done()
    
    async with asyncio.TaskGroup() as tg:  # Python 3.11+
        tg.create_task(producer())
        tg.create_task(consumer())

async def main():
    async with asyncio.TaskGroup() as tg:
        task1 = tg.create_task(fetch("url1"))
        task2 = tg.create_task(fetch("url2"))
        task3 = tg.create_task(fetch("url3"))
    # 退出上下文时，自动等待所有任务完成
    results = [t.result() for t in [task1, task2, task3]]

# 1. 忘记 await（协程不会执行）
async def bad():
    fetch_data()  # 忘记了 await！
    
# 2. 在异步代码中使用同步阻塞调用
async def bad():
    time.sleep(1)  # 应使用 await asyncio.sleep(1)

# 3. 创建任务但不 await 或 store
async def bad():
    asyncio.create_task(fetch_data())  # 任务可能被垃圾回收
    await asyncio.sleep(0.1)  # 依赖运气

# 1. 始终 await 或 create_task
async def good():
    result = await fetch_data()  # 方式1：等待结果
    task = asyncio.create_task(fetch_data())  # 方式2：保存任务引用
    # 稍后 await task

# 2. 使用 asyncio.to_thread 处理阻塞代码
async def good():
    result = await asyncio.to_thread(time.sleep, 1)  # 在线程池中执行

# 3. 使用 TaskGroup 自动管理（Python 3.11+）
async def good():
    async with asyncio.TaskGroup() as tg:
        task = tg.create_task(fetch_data())

import asyncio
import aiohttp

async def fetch_url(session, url):
    try:
        async with session.get(url, timeout=10) as response:
            return await response.text()
    except Exception as e:
        print(f"Error fetching {url}: {e}")
        return None

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        return await asyncio.gather(*tasks)

async def main():
    urls = [
        "https://api.example.com/1",
        "https://api.example.com/2",
        "https://api.example.com/3",
    ]
    results = await fetch_all(urls)
    for url, data in zip(urls, results):
        print(f"{url}: {len(data) if data else 'Failed'} bytes")

asyncio.run(main())