import time
import requests
import asyncio
import aiohttp

# ---------------------- 同步版本 ----------------------
def sync_fetch(url):
    """同步请求单个URL（阻塞式）"""
    response = requests.get(url)
    return f"同步：请求 {url} 完成，状态码 {response.status_code}"

def sync_main():
    """模拟5个同步请求"""
    urls = ["https://httpbin.org/delay/2" for _ in range(5)]
    
    start_time = time.perf_counter()
    results = [sync_fetch(url) for url in urls]
    end_time = time.perf_counter()
    
    for res in results:
        print(res)
    print(f"\n【同步总耗时】：{end_time - start_time:.2f} 秒\n")

# ---------------------- 异步版本 ----------------------
async def async_fetch(session, url):
    """异步请求单个URL（非阻塞，让出CPU）"""
    async with session.get(url) as response:
        return f"异步：请求 {url} 完成，状态码 {response.status}"

async def async_main():
    """并发执行5个异步请求"""
    urls = ["https://httpbin.org/delay/2" for _ in range(5)]
    
    start_time = time.perf_counter()
    async with aiohttp.ClientSession() as session:
        # 创建任务列表，并发执行
        tasks = [async_fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
    end_time = time.perf_counter()
    
    for res in results:
        print(res)
    print(f"\n【异步总耗时】：{end_time - start_time:.2f} 秒")

# 运行对比
if __name__ == "__main__":
    sync_main()
    asyncio.run(async_main())

import asyncio
import time

# ---------------------- 异步版本 ----------------------
async def async_hello():
    print("异步：Hello")
    await asyncio.sleep(1)  # 模拟IO等待，主动让出CPU
    print("异步：World")

async def async_main():
    start_time = time.perf_counter()
    # 并发执行两个任务
    await asyncio.gather(
        async_hello(),
        async_hello()
    )
    end_time = time.perf_counter()
    print(f"【异步总耗时】：{end_time - start_time:.2f} 秒\n")

# ---------------------- 同步版本 ----------------------
def sync_hello():
    print("同步：Hello")
    time.sleep(1)  # 阻塞CPU，无法切换任务
    print("同步：World")

def sync_main():
    start_time = time.perf_counter()
    sync_hello()
    sync_hello()  # 串行执行，必须等前一个完成
    end_time = time.perf_counter()
    print(f"【同步总耗时】：{end_time - start_time:.2f} 秒\n")

# 运行对比
if __name__ == "__main__":
    print("===== 同步执行 =====")
    sync_main()
    
    print("===== 异步执行 =====")
    asyncio.run(async_main())

import asyncio

async def my_coroutine():
    print("协程开始执行")
    await asyncio.sleep(1)  # 模拟1秒IO等待
    return "协程执行结果"

# 启动协程（asyncio.run() 会自动创建事件循环）
result = asyncio.run(my_coroutine())
print("协程返回结果：", result)

import asyncio

async def task(name):
    print(f"【{name}】启动")
    await asyncio.sleep(1)  # 模拟IO等待
    return f"【{name}】完成"

async def main():
    print("===== 主协程启动 =====")
    # 创建3个并发任务
    tasks = [task("任务1"), task("任务2"), task("任务3")]
    # 等待所有任务完成，收集结果
    results = await asyncio.gather(*tasks)
    
    print("\n===== 所有任务执行完成 =====")
    for res in results:
        print(res)

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import time

async def my_coroutine():
    print("协程开始执行")
    await asyncio.sleep(1)
    return "协程执行结果"

async def gather_tasks():
    """聚合多个协程任务"""
    return await asyncio.gather(
        my_coroutine(),
        my_coroutine(),
        my_coroutine()
    )

if __name__ == "__main__":
    start_time = time.perf_counter()

    # 手动创建并绑定事件循环
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    
    try:
        # 运行直到任务完成
        results = loop.run_until_complete(gather_tasks())
    finally:
        # 关闭事件循环（释放资源）
        loop.close()

    end_time = time.perf_counter()
    print("任务结果：", results)
    print(f"总耗时：{end_time - start_time:.2f} 秒")

import asyncio
import aiofiles

async def read_file(file_path):
    # 异步打开文件（async with 是异步上下文管理器）
    async with aiofiles.open(file_path, 'r', encoding='utf-8') as f:
        data = await f.read()  # 异步读取，不阻塞事件循环
        print("文件内容：")
        print(data)

# 启动异步文件读取
asyncio.run(read_file('flag.txt'))