协程

import time
import asyncio
def blocking_task(name):
    time.sleep(3)
    return "done"

async def async_task(name):
    print(f"{name}: start")
    result = await asyncio.to_thread(blocking_task, name)
    print(f"{name}: end")
    return result

async def main():
    tasks = [
        asyncio.create_task(async_task("task1")),
        asyncio.create_task(async_task("task2")),
        asyncio.create_task(async_task("task3"))
    ]
    await asyncio.gather(*tasks)

asyncio.run(main())

import asyncio
import time

def blocking_task():
    time.sleep(3)

async def async_task():
    loop = asyncio.get_running_loop()
    print("Before blocking")
    await loop.run_in_executor(None, blocking_task)  # 放线程池里跑，不阻塞事件循环
    print("After blocking")

async def main():
    task = asyncio.create_task(async_task())
    await task

asyncio.run(main())

import asyncio
import time
import threading
def blocking_task():
    print(f"开始阻塞任务，线程: {threading.current_thread().name}")
    time.sleep(2)
    print("阻塞任务完成")

async def main():
    print(f"主事件循环线程: {threading.current_thread().name}")
    await asyncio.to_thread(blocking_task)
    print("阻塞任务await结束，继续事件循环")

asyncio.run(main())

主事件循环线程: MainThread
开始阻塞任务，线程: ThreadPoolExecutor-0_0
阻塞任务完成
阻塞任务await结束，继续事件循环

import asyncio
import time
import threading

def blocking_task(i):
    print(f"开始阻塞任务{i}，线程: {threading.current_thread().name}")
    time.sleep(2)
    print(f"阻塞任务{i}完成")

async def main():
    print(f"主事件循环线程: {threading.current_thread().name}")
    tasks = [blocking_task(i) for i in range(3)]    
    print("所有阻塞任务完成，继续事件循环")
asyncio.run(main())

主事件循环线程: MainThread
开始阻塞任务0，线程: MainThread
阻塞任务0完成
开始阻塞任务1，线程: MainThread
阻塞任务1完成
开始阻塞任务2，线程: MainThread
阻塞任务2完成
所有阻塞任务完成，继续事件循环

import asyncio
import time
import threading

def blocking_task(i):
    print(f"开始阻塞任务{i}，线程: {threading.current_thread().name}")
    time.sleep(2)
    print(f"阻塞任务{i}完成")

async def main():
    print(f"主事件循环线程: {threading.current_thread().name}")
    
    # 并发启动3个阻塞任务
    tasks = [asyncio.to_thread(blocking_task, i) for i in range(3)]

    # 等待所有任务完成
    await asyncio.gather(*tasks)
    
    print("所有阻塞任务完成，继续事件循环")

asyncio.run(main())

主事件循环线程: MainThread
开始阻塞任务0，线程: asyncio_0
开始阻塞任务1，线程: asyncio_1
开始阻塞任务2，线程: asyncio_2
阻塞任务0完成
阻塞任务1完成
阻塞任务2完成
所有阻塞任务完成，继续事件循环

Python asyncio:
[Event Loop Thread]
   |---> Coroutine A (running)
   |---> Coroutine B (waiting for IO)
   |---> Coroutine C (running)

Python threading:
[Thread1]  [Thread2]  [Thread3]  (OS schedules these threads, but only one can hold GIL)

Java threading:
[Thread1]  [Thread2]  [Thread3]  (OS schedules real parallel threads on multiple CPU cores)