// ブロッキングI/Oのイメージ（擬似コード）
function handleRequest(socket: Socket): void {
  // 1. リクエストを読み取り（ブロック）
  const request = socket.read(); // ← ここでスレッドが停止
 
  // 2. DBに問い合わせ（ブロック）
  const data = database.query("SELECT * FROM users"); // ← ここでスレッドが停止
 
  // 3. 外部APIを呼び出し（ブロック）
  const externalData = http.get("https://api.example.com/data"); // ← ここでスレッドが停止
 
  // 4. レスポンスを書き込み（ブロック）
  socket.write(buildResponse(data, externalData)); // ← ここでスレッドが停止
}

// Java: 伝統的なブロッキングサーバー
import java.net.ServerSocket;
import java.net.Socket;
import java.io.*;
 
public class BlockingServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
 
        while (true) {
            // accept() はクライアント接続までブロック
            Socket clientSocket = serverSocket.accept();
 
            // 各接続に1スレッドを割り当て
            new Thread(() -> {
                try {
                    BufferedReader reader = new BufferedReader(
                        new InputStreamReader(clientSocket.getInputStream())
                    );
                    PrintWriter writer = new PrintWriter(
                        clientSocket.getOutputStream(), true
                    );
 
                    // readline() はデータ到着までブロック
                    String line = reader.readLine();
                    writer.println("Echo: " + line);
 
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        // 問題: 10,000接続 = 10,000スレッド（各1MB） = 10GBメモリ
    }
}

// Node.js: ノンブロッキングI/O
import * as http from 'http';
import * as fs from 'fs';
 
const server = http.createServer(async (req, res) => {
  // ノンブロッキング: I/O開始後すぐに制御が戻る
  // 他のリクエストを処理できる
  try {
    const data = await fs.promises.readFile('data.json', 'utf8');
    const parsed = JSON.parse(data);
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(parsed));
  } catch (err) {
    res.writeHead(500);
    res.end('Internal Server Error');
  }
});
 
server.listen(8080);
// 1スレッドで数万の同時接続を処理可能

// epoll の使い方（C言語、Linux）
#include <sys/epoll.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
 
int main() {
    int epoll_fd = epoll_create1(0);
 
    struct epoll_event event;
    event.events = EPOLLIN;  // 読み取り可能イベントを監視
    event.data.fd = socket_fd;
 
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &event);
 
    struct epoll_event events[MAX_EVENTS];
 
    while (1) {
        // イベント待ち（ブロックするが、複数fdを同時に監視）
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
 
        for (int i = 0; i < nfds; i++) {
            if (events[i].events & EPOLLIN) {
                // データが読み取り可能
                handle_read(events[i].data.fd);
            }
        }
    }
}

// 同期的な処理（Node.jsでは非推奨）
function syncHandler(req: Request): Response {
  const user = db.getUserSync(req.userId);      // 10ms 待ち
  const orders = db.getOrdersSync(user.id);     // 15ms 待ち
  const recommendations = api.getRecsSync(user); // 50ms 待ち
  return { user, orders, recommendations };
  // 合計: 75ms（直列実行）
}
 
// 非同期処理（並行実行）
async function asyncHandler(req: Request): Promise<Response> {
  const user = await db.getUser(req.userId);    // 10ms
  // user を取得後、残りを並行実行
  const [orders, recommendations] = await Promise.all([
    db.getOrders(user.id),                      // 15ms ┐
    api.getRecs(user),                           // 50ms ┤ 並行
  ]);                                            //      ┘ max = 50ms
  return { user, orders, recommendations };
  // 合計: 10 + 50 = 60ms（20%高速化）
}

// ECサイトの商品ページ: 同期版
async function getProductPageSync(productId: string) {
  const start = Date.now();
 
  const product = await getProduct(productId);           // 20ms
  const reviews = await getReviews(productId);           // 30ms
  const relatedProducts = await getRelated(productId);   // 25ms
  const inventory = await getInventory(productId);       // 15ms
  const pricing = await getPricing(productId);           // 10ms
  const seller = await getSeller(product.sellerId);      // 20ms
 
  console.log(`直列実行: ${Date.now() - start}ms`);
  // → 120ms
  return { product, reviews, relatedProducts, inventory, pricing, seller };
}
 
// ECサイトの商品ページ: 最適化版
async function getProductPageOptimized(productId: string) {
  const start = Date.now();
 
  // Stage 1: 依存関係のないものを並行実行
  const [product, reviews, relatedProducts, inventory, pricing] =
    await Promise.all([
      getProduct(productId),           // 20ms ┐
      getReviews(productId),           // 30ms ┤
      getRelated(productId),           // 25ms ┤ 並行
      getInventory(productId),         // 15ms ┤
      getPricing(productId),           // 10ms ┘
    ]);
  // Stage 1: max(20, 30, 25, 15, 10) = 30ms
 
  // Stage 2: product に依存する処理
  const seller = await getSeller(product.sellerId); // 20ms
 
  console.log(`最適化版: ${Date.now() - start}ms`);
  // → 50ms（58%高速化）
  return { product, reviews, relatedProducts, inventory, pricing, seller };
}

// JavaScript: シングルスレッド + イベントループ
// ブラウザ / Node.js 共通のモデル
 
// 1. Promise ベース
function fetchUserData(userId: string): Promise<User> {
  return fetch(`/api/users/${userId}`)
    .then(response => {
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      return response.json();
    });
}
 
// 2. async/await（Promise の構文糖）
async function fetchUserData(userId: string): Promise<User> {
  const response = await fetch(`/api/users/${userId}`);
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}`);
  }
  return response.json();
}
 
// 3. Node.js 固有: Worker Threads（CPU集約型用）
import { Worker, isMainThread, parentPort } from 'worker_threads';
 
if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on('message', (result) => {
    console.log('計算結果:', result);
  });
  worker.postMessage({ data: largeArray });
} else {
  parentPort?.on('message', (msg) => {
    // CPU集約的な処理をワーカースレッドで実行
    const result = heavyComputation(msg.data);
    parentPort?.postMessage(result);
  });
}

import asyncio
import aiohttp
 
# Python: asyncio イベントループ
# GIL（Global Interpreter Lock）があるため、
# CPU並列はmultiprocessing、I/O並行はasyncioを使う
 
# 基本的な非同期関数
async def fetch_user(user_id: str) -> dict:
    async with aiohttp.ClientSession() as session:
        async with session.get(f"https://api.example.com/users/{user_id}") as resp:
            return await resp.json()
 
# 並行実行
async def fetch_all_users(user_ids: list[str]) -> list[dict]:
    tasks = [fetch_user(uid) for uid in user_ids]
    return await asyncio.gather(*tasks)
 
# 実行
async def main():
    users = await fetch_all_users(["user-1", "user-2", "user-3"])
    for user in users:
        print(user["name"])
 
asyncio.run(main())
 
# CPU集約型: multiprocessing
from concurrent.futures import ProcessPoolExecutor
import asyncio
 
async def cpu_intensive_async(data_list: list) -> list:
    loop = asyncio.get_event_loop()
    with ProcessPoolExecutor() as pool:
        results = await asyncio.gather(*[
            loop.run_in_executor(pool, heavy_computation, data)
            for data in data_list
        ])
    return results

package main
 
import (
    "fmt"
    "net/http"
    "sync"
    "time"
)
 
// Go: goroutine + channel
// goroutineは軽量スレッド（~2KB）、OSスレッドの上にランタイムがスケジューリング
 
// 基本的な非同期実行
func fetchURL(url string, ch chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("Error: %s", err)
        return
    }
    defer resp.Body.Close()
    ch <- fmt.Sprintf("%s: %d", url, resp.StatusCode)
}
 
func main() {
    urls := []string{
        "https://api.example.com/users",
        "https://api.example.com/orders",
        "https://api.example.com/products",
    }
 
    ch := make(chan string, len(urls))
    var wg sync.WaitGroup
 
    for _, url := range urls {
        wg.Add(1)
        go fetchURL(url, ch, &wg) // goroutineで並行実行
    }
 
    // 全完了を待つ
    go func() {
        wg.Wait()
        close(ch)
    }()
 
    for result := range ch {
        fmt.Println(result)
    }
}
 
// select による複数チャネルの待ち受け
func fetchWithTimeout(url string, timeout time.Duration) (string, error) {
    ch := make(chan string, 1)
    errCh := make(chan error, 1)
 
    go func() {
        resp, err := http.Get(url)
        if err != nil {
            errCh <- err
            return
        }
        defer resp.Body.Close()
        ch <- resp.Status
    }()
 
    select {
    case result := <-ch:
        return result, nil
    case err := <-errCh:
        return "", err
    case <-time.After(timeout):
        return "", fmt.Errorf("timeout after %v", timeout)
    }
}

use tokio;
use reqwest;
 
// Rust: async/await + ランタイム（tokio）
// ゼロコスト抽象化: async関数はステートマシンにコンパイルされる
// Future は lazy: .await するまで実行されない
 
async fn fetch_user(user_id: &str) -> Result<User, reqwest::Error> {
    let url = format!("https://api.example.com/users/{}", user_id);
    let user: User = reqwest::get(&url)
        .await?
        .json()
        .await?;
    Ok(user)
}
 
// 並行実行
async fn fetch_all_data(user_id: &str) -> Result<Dashboard, AppError> {
    // tokio::join! で並行実行
    let (user, orders, notifications) = tokio::join!(
        fetch_user(user_id),
        fetch_orders(user_id),
        fetch_notifications(user_id),
    );
 
    Ok(Dashboard {
        user: user?,
        orders: orders?,
        notifications: notifications?,
    })
}
 
// tokio::spawn でバックグラウンドタスク
async fn background_processing() {
    let handle = tokio::spawn(async {
        // バックグラウンドで実行
        heavy_async_work().await
    });
 
    // 他の処理を続行
    do_other_work().await;
 
    // バックグラウンドタスクの結果を取得
    let result = handle.await.unwrap();
}
 
#[tokio::main]
async fn main() {
    let dashboard = fetch_all_data("user-123").await.unwrap();
    println!("{:?}", dashboard);
}

import java.util.concurrent.*;
 
// Java: CompletableFuture (Java 8+)
// 仮想スレッド (Java 21+ / Project Loom)
 
public class AsyncExample {
 
    // CompletableFuture ベース
    public CompletableFuture<Dashboard> getDashboard(String userId) {
        CompletableFuture<User> userFuture =
            CompletableFuture.supplyAsync(() -> userRepo.findById(userId));
 
        CompletableFuture<List<Order>> ordersFuture =
            CompletableFuture.supplyAsync(() -> orderRepo.findByUserId(userId));
 
        CompletableFuture<List<Notification>> notifFuture =
            CompletableFuture.supplyAsync(() -> notifRepo.findByUserId(userId));
 
        // 全て完了したら結合
        return CompletableFuture.allOf(userFuture, ordersFuture, notifFuture)
            .thenApply(v -> new Dashboard(
                userFuture.join(),
                ordersFuture.join(),
                notifFuture.join()
            ));
    }
 
    // Java 21: 仮想スレッド（Project Loom）
    public Dashboard getDashboardVirtualThreads(String userId) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var userTask = scope.fork(() -> userRepo.findById(userId));
            var ordersTask = scope.fork(() -> orderRepo.findByUserId(userId));
            var notifTask = scope.fork(() -> notifRepo.findByUserId(userId));
 
            scope.join();
            scope.throwIfFailed();
 
            return new Dashboard(
                userTask.get(),
                ordersTask.get(),
                notifTask.get()
            );
        }
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
 
// C#: Task + async/await
// .NET の非同期モデルは最も成熟したものの一つ
 
public class AsyncService
{
    private readonly HttpClient _httpClient;
 
    // async/await 基本
    public async Task<Dashboard> GetDashboardAsync(string userId)
    {
        var user = await GetUserAsync(userId);
 
        // 並行実行
        var ordersTask = GetOrdersAsync(userId);
        var notificationsTask = GetNotificationsAsync(userId);
 
        await Task.WhenAll(ordersTask, notificationsTask);
 
        return new Dashboard
        {
            User = user,
            Orders = ordersTask.Result,
            Notifications = notificationsTask.Result
        };
    }
 
    // キャンセルトークン対応
    public async Task<User> GetUserAsync(
        string userId,
        CancellationToken cancellationToken = default)
    {
        var response = await _httpClient.GetAsync(
            $"/api/users/{userId}",
            cancellationToken
        );
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<User>(
            cancellationToken: cancellationToken
        );
    }
 
    // ValueTask: ホットパス最適化
    public ValueTask<CachedData> GetCachedDataAsync(string key)
    {
        if (_cache.TryGetValue(key, out var cached))
        {
            // キャッシュヒット時はヒープ割り当てなし
            return new ValueTask<CachedData>(cached);
        }
 
        // キャッシュミス時のみ非同期処理
        return new ValueTask<CachedData>(FetchAndCacheAsync(key));
    }
}

// シナリオ1: ファイル処理
// ✅ 大量のファイルを非同期で並行処理
async function processFiles(filePaths: string[]): Promise<void> {
  const CONCURRENCY = 10; // 同時に10ファイルまで
  const results: string[] = [];
 
  for (let i = 0; i < filePaths.length; i += CONCURRENCY) {
    const batch = filePaths.slice(i, i + CONCURRENCY);
    const batchResults = await Promise.all(
      batch.map(async (filePath) => {
        const content = await fs.promises.readFile(filePath, 'utf8');
        return processContent(content);
      })
    );
    results.push(...batchResults);
  }
}
 
// ❌ 小さなファイル1つだけなら同期でも可
// （起動スクリプト、設定読み込みなど）
const config = JSON.parse(fs.readFileSync('config.json', 'utf8'));

# シナリオ2: Webスクレイピング
import asyncio
import aiohttp
from typing import List, Dict
 
# ✅ 多数のURLを非同期で並行取得
async def scrape_urls(urls: list[str]) -> list[dict]:
    semaphore = asyncio.Semaphore(20)  # 同時接続数制限
 
    async def fetch_one(session: aiohttp.ClientSession, url: str) -> dict:
        async with semaphore:
            async with session.get(url) as response:
                html = await response.text()
                return {"url": url, "status": response.status, "html": html}
 
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_one(session, url) for url in urls]
        return await asyncio.gather(*tasks, return_exceptions=True)
 
# 100件のURLを同時20並列で取得
# 同期: 100 × 200ms = 20秒
# 非同期: 100 / 20 × 200ms = 1秒（20倍高速）

// シナリオ3: マイクロサービスのAPI Gateway
package main
 
import (
    "context"
    "net/http"
    "time"
    "encoding/json"
    "golang.org/x/sync/errgroup"
)
 
type AggregatedResponse struct {
    User          *User          `json:"user"`
    Orders        []Order        `json:"orders"`
    Notifications []Notification `json:"notifications"`
}
 
// ✅ 複数のマイクロサービスを並行呼び出し
func aggregateHandler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
    defer cancel()
 
    userID := r.URL.Query().Get("user_id")
    var resp AggregatedResponse
 
    g, ctx := errgroup.WithContext(ctx)
 
    g.Go(func() error {
        user, err := fetchUser(ctx, userID)
        if err != nil {
            return err
        }
        resp.User = user
        return nil
    })
 
    g.Go(func() error {
        orders, err := fetchOrders(ctx, userID)
        if err != nil {
            return err
        }
        resp.Orders = orders
        return nil
    })
 
    g.Go(func() error {
        notifs, err := fetchNotifications(ctx, userID)
        if err != nil {
            return err
        }
        resp.Notifications = notifs
        return nil
    })
 
    if err := g.Wait(); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
 
    json.NewEncoder(w).Encode(resp)
}

// ❌ アンチパターン1: CPU集約処理をイベントループで実行
async function badImageProcessing(images: Buffer[]): Promise<Buffer[]> {
  // イベントループをブロックしてしまう
  return images.map(img => {
    // 重い画像処理（同期的にCPUを占有）
    return sharp(img).resize(800, 600).toBuffer(); // ← 同期API
  });
}
 
// ✅ CPU集約処理はWorker Threadsに委譲
import { Worker } from 'worker_threads';
 
async function goodImageProcessing(images: Buffer[]): Promise<Buffer[]> {
  const worker = new Worker('./image-worker.js');
  return new Promise((resolve, reject) => {
    worker.postMessage(images);
    worker.on('message', resolve);
    worker.on('error', reject);
  });
}
 
// ❌ アンチパターン2: 不必要な非同期化
async function unnecessary(): Promise<number> {
  return 1 + 1; // ← 同期で十分な処理を非同期にする意味がない
}
 
// ❌ アンチパターン3: 非同期処理の結果を無視
function fireAndForget(data: Data): void {
  saveToDatabase(data); // Promiseの結果を無視 → エラーが見えなくなる
}
 
// ✅ 結果を適切にハンドリング
async function properSave(data: Data): Promise<void> {
  try {
    await saveToDatabase(data);
  } catch (error) {
    logger.error('Failed to save data', error);
    throw error; // 呼び出し元に伝播
  }
}

// タイムアウト付きfetch
async function fetchWithTimeout(
  url: string,
  options: RequestInit = {},
  timeoutMs: number = 5000,
): Promise<Response> {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
 
  try {
    const response = await fetch(url, {
      ...options,
      signal: controller.signal,
    });
    return response;
  } catch (error) {
    if (error instanceof DOMException && error.name === 'AbortError') {
      throw new Error(`Request timeout after ${timeoutMs}ms: ${url}`);
    }
    throw error;
  } finally {
    clearTimeout(timeoutId);
  }
}
 
// 使用例
try {
  const response = await fetchWithTimeout('https://api.example.com/data', {}, 3000);
  const data = await response.json();
} catch (error) {
  console.error('リクエスト失敗:', error.message);
}

// 指数バックオフ付きリトライ
async function retryWithBackoff<T>(
  fn: () => Promise<T>,
  options: {
    maxRetries?: number;
    initialDelayMs?: number;
    maxDelayMs?: number;
    backoffMultiplier?: number;
    retryableErrors?: (error: unknown) => boolean;
  } = {},
): Promise<T> {
  const {
    maxRetries = 3,
    initialDelayMs = 1000,
    maxDelayMs = 30000,
    backoffMultiplier = 2,
    retryableErrors = () => true,
  } = options;
 
  let lastError: unknown;
  let delay = initialDelayMs;
 
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;
 
      if (attempt === maxRetries || !retryableErrors(error)) {
        throw error;
      }
 
      // ジッター（ランダム揺らぎ）を追加
      const jitter = delay * 0.1 * Math.random();
      const actualDelay = Math.min(delay + jitter, maxDelayMs);
 
      console.warn(
        `Attempt ${attempt + 1} failed, retrying in ${actualDelay}ms...`,
        error
      );
 
      await new Promise(resolve => setTimeout(resolve, actualDelay));
      delay *= backoffMultiplier;
    }
  }
 
  throw lastError;
}
 
// 使用例
const data = await retryWithBackoff(
  () => fetchWithTimeout('https://api.example.com/data'),
  {
    maxRetries: 3,
    initialDelayMs: 1000,
    retryableErrors: (error) => {
      // 5xx エラーのみリトライ
      return error instanceof Error && error.message.includes('5');
    },
  }
);

// セマフォ: 同時実行数を制限
class Semaphore {
  private permits: number;
  private queue: (() => void)[] = [];
 
  constructor(permits: number) {
    this.permits = permits;
  }
 
  async acquire(): Promise<void> {
    if (this.permits > 0) {
      this.permits--;
      return;
    }
 
    return new Promise<void>((resolve) => {
      this.queue.push(resolve);
    });
  }
 
  release(): void {
    const next = this.queue.shift();
    if (next) {
      next();
    } else {
      this.permits++;
    }
  }
 
  async use<T>(fn: () => Promise<T>): Promise<T> {
    await this.acquire();
    try {
      return await fn();
    } finally {
      this.release();
    }
  }
}
 
// 使用例: 同時5並列でAPI呼び出し
const semaphore = new Semaphore(5);
const urls = Array.from({ length: 100 }, (_, i) => `https://api.example.com/item/${i}`);
 
const results = await Promise.all(
  urls.map(url =>
    semaphore.use(async () => {
      const response = await fetch(url);
      return response.json();
    })
  )
);

// AbortController を使ったキャンセル
class CancellableTask<T> {
  private controller: AbortController;
  private promise: Promise<T>;
 
  constructor(executor: (signal: AbortSignal) => Promise<T>) {
    this.controller = new AbortController();
    this.promise = executor(this.controller.signal);
  }
 
  get result(): Promise<T> {
    return this.promise;
  }
 
  cancel(reason?: string): void {
    this.controller.abort(reason);
  }
}
 
// 使用例: 検索の自動キャンセル
let currentSearch: CancellableTask<SearchResult[]> | null = null;
 
async function search(query: string): Promise<SearchResult[]> {
  // 前の検索をキャンセル
  currentSearch?.cancel('New search started');
 
  currentSearch = new CancellableTask(async (signal) => {
    const response = await fetch(`/api/search?q=${query}`, { signal });
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return response.json();
  });
 
  return currentSearch.result;
}

// 処理時間の計測
async function benchmark<T>(
  name: string,
  fn: () => Promise<T>,
  iterations: number = 10,
): Promise<{ name: string; avg: number; min: number; max: number; p95: number }> {
  const times: number[] = [];
 
  for (let i = 0; i < iterations; i++) {
    const start = performance.now();
    await fn();
    times.push(performance.now() - start);
  }
 
  times.sort((a, b) => a - b);
 
  return {
    name,
    avg: times.reduce((sum, t) => sum + t, 0) / times.length,
    min: times[0],
    max: times[times.length - 1],
    p95: times[Math.floor(times.length * 0.95)],
  };
}
 
// 比較テスト
async function compareSyncVsAsync(): Promise<void> {
  const syncResult = await benchmark('Sequential', async () => {
    const a = await fetchA();
    const b = await fetchB();
    const c = await fetchC();
    return { a, b, c };
  });
 
  const asyncResult = await benchmark('Parallel', async () => {
    const [a, b, c] = await Promise.all([
      fetchA(),
      fetchB(),
      fetchC(),
    ]);
    return { a, b, c };
  });
 
  console.table([syncResult, asyncResult]);
  // ┌─────────────┬──────────┬──────────┬──────────┬──────────┐
  // │ name        │ avg      │ min      │ max      │ p95      │
  // ├─────────────┼──────────┼──────────┼──────────┼──────────┤
  // │ Sequential  │ 312.5ms  │ 301.2ms  │ 325.8ms  │ 321.3ms  │
  // │ Parallel    │ 105.3ms  │ 100.1ms  │ 115.2ms  │ 112.7ms  │
  // └─────────────┴──────────┴──────────┴──────────┴──────────┘
}

import { describe, it, expect, vi } from 'vitest';
 
// 非同期関数のテスト
describe('fetchUserData', () => {
  // 基本テスト
  it('ユーザーデータを正常に取得できる', async () => {
    const user = await fetchUserData('user-123');
    expect(user).toEqual({
      id: 'user-123',
      name: 'テスト太郎',
    });
  });
 
  // エラーテスト
  it('存在しないユーザーでエラーをスロー', async () => {
    await expect(fetchUserData('nonexistent'))
      .rejects.toThrow('User not found');
  });
 
  // タイムアウトテスト
  it('タイムアウト時にエラーをスロー', async () => {
    vi.useFakeTimers();
 
    const promise = fetchWithTimeout('https://slow.api.com', {}, 3000);
 
    vi.advanceTimersByTime(3000);
 
    await expect(promise).rejects.toThrow('timeout');
 
    vi.useRealTimers();
  });
 
  // モック使用
  it('APIをモックしてテスト', async () => {
    const mockFetch = vi.fn().mockResolvedValue({
      ok: true,
      json: () => Promise.resolve({ id: '123', name: 'Test' }),
    });
 
    global.fetch = mockFetch;
 
    const result = await fetchUserData('123');
    expect(result.name).toBe('Test');
    expect(mockFetch).toHaveBeenCalledWith(
      expect.stringContaining('/users/123')
    );
  });
});

describe('Promise.all パターンのテスト', () => {
  it('並行実行の順序非依存性を確認', async () => {
    const results: string[] = [];
 
    const task1 = async () => {
      await sleep(100);
      results.push('task1');
      return 'result1';
    };
 
    const task2 = async () => {
      await sleep(50);
      results.push('task2');
      return 'result2';
    };
 
    const [r1, r2] = await Promise.all([task1(), task2()]);
 
    expect(r1).toBe('result1');
    expect(r2).toBe('result2');
    // task2 の方が先に完了するが、結果の順序は保持される
    expect(results).toEqual(['task2', 'task1']);
  });
 
  it('部分的な失敗をハンドリング', async () => {
    const results = await Promise.allSettled([
      Promise.resolve('success'),
      Promise.reject(new Error('failure')),
      Promise.resolve('success2'),
    ]);
 
    expect(results[0]).toEqual({ status: 'fulfilled', value: 'success' });
    expect(results[1].status).toBe('rejected');
    expect(results[2]).toEqual({ status: 'fulfilled', value: 'success2' });
  });
});

// async_hooks を使った非同期処理のトレース（Node.js）
import { AsyncLocalStorage } from 'async_hooks';
 
const requestStorage = new AsyncLocalStorage<{ requestId: string }>();
 
// リクエストIDをコンテキストとして伝播
async function handleRequest(req: Request): Promise<Response> {
  const requestId = generateRequestId();
 
  return requestStorage.run({ requestId }, async () => {
    logger.info(`[${requestId}] リクエスト開始`);
 
    const user = await getUser(req.userId);
    logger.info(`[${requestId}] ユーザー取得完了`);
 
    const data = await processData(user);
    logger.info(`[${requestId}] データ処理完了`);
 
    return new Response(JSON.stringify(data));
  });
}
 
// どの非同期処理からでもリクエストIDを取得可能
function getRequestId(): string {
  return requestStorage.getStore()?.requestId ?? 'unknown';
}

// Node.js: 未処理のPromise Rejectionを検出
process.on('unhandledRejection', (reason, promise) => {
  console.error('未処理のPromise Rejection:', reason);
  console.error('Promise:', promise);
  // 本番環境ではログに記録してアラートを送信
  logger.error('Unhandled Promise Rejection', {
    reason: reason instanceof Error ? reason.message : String(reason),
    stack: reason instanceof Error ? reason.stack : undefined,
  });
});
 
// ブラウザ
window.addEventListener('unhandledrejection', (event) => {
  console.error('未処理のPromise Rejection:', event.reason);
  event.preventDefault(); // デフォルトのコンソールエラーを抑制
  // エラー追跡サービスに報告
  errorTracker.captureException(event.reason);
});

// 非同期処理のパフォーマンスを可視化
class AsyncProfiler {
  private traces: Map<string, { start: number; end?: number }[]> = new Map();
 
  wrap<T>(name: string, fn: () => Promise<T>): Promise<T> {
    const entry = { start: performance.now() };
 
    if (!this.traces.has(name)) {
      this.traces.set(name, []);
    }
    this.traces.get(name)!.push(entry);
 
    return fn().finally(() => {
      entry.end = performance.now();
    });
  }
 
  report(): void {
    console.log('\n=== Async Performance Report ===');
    for (const [name, entries] of this.traces) {
      const durations = entries
        .filter(e => e.end !== undefined)
        .map(e => e.end! - e.start);
      const avg = durations.reduce((s, d) => s + d, 0) / durations.length;
      const max = Math.max(...durations);
      console.log(`${name}: calls=${entries.length}, avg=${avg.toFixed(1)}ms, max=${max.toFixed(1)}ms`);
    }
  }
}
 
// 使用例
const profiler = new AsyncProfiler();
 
const user = await profiler.wrap('getUser', () => getUser(userId));
const [orders, reviews] = await Promise.all([
  profiler.wrap('getOrders', () => getOrders(user.id)),
  profiler.wrap('getReviews', () => getReviews(user.id)),
]);
 
profiler.report();
// === Async Performance Report ===
// getUser: calls=1, avg=12.3ms, max=12.3ms
// getOrders: calls=1, avg=18.7ms, max=18.7ms
// getReviews: calls=1, avg=45.2ms, max=45.2ms

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()