async/awaitの裏側 — イベントループ、コルーチン、そしてランタイムの仕組み

async function fetchData() {
  const response = await fetch("/api/data");
  const json = await response.json();
  return json;
}

console.log("1");             // 同期
 
setTimeout(() => {
  console.log("4");           // マクロタスク
}, 0);
 
Promise.resolve().then(() => {
  console.log("3");           // マイクロタスク
});
 
console.log("2");             // 同期
 
// 出力順: 1, 2, 3, 4

// async/await で書いたコード
async function example() {
  console.log("A");
  const result = await fetchData();
  console.log("B");
  return result;
}
 
// エンジンが内部的に行う変換（概念的）
function example() {
  console.log("A");
  return fetchData().then((result) => {
    console.log("B");
    return result;
  });
}

import asyncio
 
async def fetch_data():
    print("fetch start")
    await asyncio.sleep(1)  # I/O操作をシミュレート
    print("fetch done")
    return 42

coro = fetch_data()   # 関数本体はまだ実行されない！
print(type(coro))      # <class 'coroutine'>

import asyncio
 
async def main():
    result = await fetch_data()
    print(result)
 
# イベントループを作成して実行
asyncio.run(main())

# 概念的な内部動作
async def example():
    result = await some_coroutine()
    print(result)
 
# 内部的には（簡略化）:
# 1. some_coroutine() を呼んでコルーチンオブジェクトを取得
# 2. .send(None) で実行を進める
# 3. コルーチンが中断したら、イベントループに制御を返す
# 4. I/O完了後、.send(result) で結果を渡して再開

pub trait Future {
    type Output;
    
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}
 
pub enum Poll<T> {
    Ready(T),    // 完了: 結果を返す
    Pending,     // 未完了: 後で再度ポーリングしてほしい
}

async fn example() -> i32 {
    let a = fetch_a().await;  // 中断点1
    let b = fetch_b().await;  // 中断点2
    a + b
}
 
// コンパイラが生成する状態機械（概念的）:
enum ExampleFuture {
    Start,
    WaitingA { future_a: FetchAFuture },
    WaitingB { a: i32, future_b: FetchBFuture },
    Done,
}
 
impl Future for ExampleFuture {
    type Output = i32;
    
    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<i32> {
        loop {
            match self.state {
                Start => {
                    self.future_a = fetch_a();
                    self.state = WaitingA;
                }
                WaitingA => {
                    match self.future_a.poll(cx) {
                        Poll::Ready(a) => {
                            self.a = a;
                            self.future_b = fetch_b();
                            self.state = WaitingB;
                        }
                        Poll::Pending => return Poll::Pending,
                    }
                }
                WaitingB => {
                    match self.future_b.poll(cx) {
                        Poll::Ready(b) => {
                            return Poll::Ready(self.a + b);
                        }
                        Poll::Pending => return Poll::Pending,
                    }
                }
                Done => panic!("polled after completion"),
            }
        }
    }
}

// Context にはWakerが含まれている
pub struct Context<'a> {
    waker: &'a Waker,
}

1. ランタイムがFuture.poll()を呼ぶ
2. Futureは内部でI/Oを開始し、Wakerをカーネルに登録
3. Poll::Pending を返す
4. ランタイムは他のFutureをポーリング
5. I/O完了 → カーネルがWakerを起動
6. ランタイムが該当Futureを再度poll()
7. Poll::Ready(result) を返す

#[tokio::main]
async fn main() {
    let result = fetch_data().await;
    println!("{result}");
}

# NG: sync から async を直接は呼べない
def sync_function():
    result = await async_function()  # SyntaxError!
 
# OK: asyncio.run() でブリッジ
def sync_function():
    result = asyncio.run(async_function())

// NG: awaitを忘れるとPromiseオブジェクトが返る
async function bad() {
  const data = fetch("/api");  // await がない！
  console.log(data);            // Promise オブジェクトが出力される
}
 
// NG: 直列実行になってしまう
async function sequential() {
  const a = await fetchA();  // 1秒待ち
  const b = await fetchB();  // さらに1秒待ち → 合計2秒
}
 
// OK: Promise.all で並行実行
async function parallel() {
  const [a, b] = await Promise.all([fetchA(), fetchB()]);  // 合計1秒
}

# NG: ブロッキングI/Oをasyncコード内で使う
async def bad():
    import requests
    response = requests.get("https://example.com")  # イベントループをブロック！
 
# OK: 非同期ライブラリを使う
async def good():
    import aiohttp
    async with aiohttp.ClientSession() as session:
        response = await session.get("https://example.com")
 
# 独立したタスクの並行実行
async def gather_example():
    results = await asyncio.gather(
        fetch_a(),
        fetch_b(),
        fetch_c(),
    )

// NG: async fn内でブロッキング操作
async fn bad() {
    std::thread::sleep(Duration::from_secs(1)); // ランタイムのスレッドをブロック！
}
 
// OK: tokioの非同期版を使う
async fn good() {
    tokio::time::sleep(Duration::from_secs(1)).await;
}
 
// OK: CPUバウンド処理はspawn_blockingで別スレッドに逃がす
async fn cpu_work() {
    let result = tokio::task::spawn_blocking(|| {
        heavy_computation()
    }).await.unwrap();
}