// 実行順序クイズ: 以下のコードの出力順は？
console.log('1: スクリプト開始');
 
setTimeout(() => {
    console.log('2: setTimeout');
}, 0);
 
Promise.resolve()
    .then(() => {
        console.log('3: Promise.then');
    })
    .then(() => {
        console.log('4: Promise.then (chained)');
    });
 
queueMicrotask(() => {
    console.log('5: queueMicrotask');
});
 
console.log('6: スクリプト終了');
 
// 出力順:
// 1: スクリプト開始
// 6: スクリプト終了
// 3: Promise.then         ← マイクロタスク（同期コード完了直後）
// 5: queueMicrotask       ← マイクロタスク
// 4: Promise.then (chained) ← マイクロタスク
// 2: setTimeout           ← マクロタスク（次のイベントループ）

// ===== Stage 1: コールバック地獄 =====
function loadDashboard(userId, callback) {
    getUser(userId, function(err, user) {
        if (err) return callback(err);
        getPosts(user.id, function(err, posts) {
            if (err) return callback(err);
            getComments(posts[0].id, function(err, comments) {
                if (err) return callback(err);
                getNotifications(user.id, function(err, notifications) {
                    if (err) return callback(err);
                    callback(null, {
                        user: user,
                        posts: posts,
                        comments: comments,
                        notifications: notifications
                    });
                });
            });
        });
    });
}
// 問題: ネストが深い、エラー処理が散在、可読性が低い
 
// ===== Stage 2: Promise チェーン =====
function loadDashboard(userId) {
    let userData;
    return getUser(userId)
        .then(user => {
            userData = user;
            return getPosts(user.id);
        })
        .then(posts => {
            return getComments(posts[0].id)
                .then(comments => ({ posts, comments }));
        })
        .then(({ posts, comments }) => {
            return getNotifications(userData.id)
                .then(notifications => ({
                    user: userData,
                    posts,
                    comments,
                    notifications
                }));
        })
        .catch(err => {
            console.error('Dashboard load failed:', err);
            throw err;
        });
}
// 改善: フラットなチェーン、統一的なエラー処理
// 問題: まだ複雑、中間変数の管理が面倒
 
// ===== Stage 3: async/await =====
async function loadDashboard(userId) {
    try {
        const user = await getUser(userId);
        const posts = await getPosts(user.id);
        const comments = await getComments(posts[0].id);
        const notifications = await getNotifications(user.id);
 
        return { user, posts, comments, notifications };
    } catch (err) {
        console.error('Dashboard load failed:', err);
        throw err;
    }
}
// 改善: 同期処理と同じ見た目、直感的なエラー処理
// 注意: 上記は逐次実行。並行可能な処理は Promise.all を使う
 
// ===== Stage 3.5: async/await + 並行実行の最適化 =====
async function loadDashboard(userId) {
    try {
        const user = await getUser(userId);
 
        // posts と notifications は互いに依存しないので並行実行
        const [posts, notifications] = await Promise.all([
            getPosts(user.id),
            getNotifications(user.id),
        ]);
 
        // comments は posts に依存するので逐次実行
        const comments = await getComments(posts[0].id);
 
        return { user, posts, comments, notifications };
    } catch (err) {
        console.error('Dashboard load failed:', err);
        throw err;
    }
}

// ===== 基本: async 関数は常に Promise を返す =====
async function greet(name) {
    return `Hello, ${name}!`;
}
 
// 上記は以下と等価:
function greet(name) {
    return Promise.resolve(`Hello, ${name}!`);
}
 
// ===== await: Promise の完了を待機する =====
async function fetchUserProfile(userId) {
    // await は Promise が解決されるまで関数の実行を中断し、
    // イベントループに制御を返す
    const response = await fetch(`/api/users/${userId}`);
 
    // レスポンスが到着したら、ここから再開
    if (!response.ok) {
        throw new Error(`HTTP Error: ${response.status}`);
    }
 
    const data = await response.json();
    return data;
}
 
// ===== await を使えるのは async 関数内のみ =====
// ES2022 以降: トップレベル await が使用可能（ESM モジュールのみ）
const config = await import('./config.js');
const data = await fetch('/api/data').then(r => r.json());

// ===== Promise.all: 全て成功で完了、1つでも失敗で即座に reject =====
async function fetchAllResources() {
    try {
        const [users, products, orders] = await Promise.all([
            fetch('/api/users').then(r => r.json()),
            fetch('/api/products').then(r => r.json()),
            fetch('/api/orders').then(r => r.json()),
        ]);
        return { users, products, orders };
    } catch (error) {
        // いずれか1つが失敗した場合、他の処理も中断される
        console.error('One of the requests failed:', error);
        throw error;
    }
}
 
// ===== Promise.allSettled: 全ての結果を取得（成功/失敗問わず） =====
async function fetchAllResourcesGracefully() {
    const results = await Promise.allSettled([
        fetch('/api/users').then(r => r.json()),
        fetch('/api/products').then(r => r.json()),
        fetch('/api/orders').then(r => r.json()),
    ]);
 
    const data = {};
    results.forEach((result, index) => {
        const keys = ['users', 'products', 'orders'];
        if (result.status === 'fulfilled') {
            data[keys[index]] = result.value;
        } else {
            console.warn(`${keys[index]} failed:`, result.reason);
            data[keys[index]] = []; // フォールバック値
        }
    });
    return data;
}
 
// ===== Promise.race: 最初に完了（成功/失敗問わず）したものを返す =====
async function fetchWithTimeout(url, timeoutMs = 5000) {
    const controller = new AbortController();
 
    const result = await Promise.race([
        fetch(url, { signal: controller.signal }),
        new Promise((_, reject) => {
            setTimeout(() => {
                controller.abort();
                reject(new Error(`Timeout after ${timeoutMs}ms`));
            }, timeoutMs);
        }),
    ]);
 
    return result.json();
}
 
// ===== Promise.any: 最初に成功したものを返す（全失敗で AggregateError） =====
async function fetchFromMultipleCDNs(path) {
    try {
        const response = await Promise.any([
            fetch(`https://cdn1.example.com${path}`),
            fetch(`https://cdn2.example.com${path}`),
            fetch(`https://cdn3.example.com${path}`),
        ]);
        return response;
    } catch (error) {
        // AggregateError: 全ての CDN が失敗
        console.error('All CDNs failed:', error.errors);
        throw error;
    }
}

// ===== パターン1: try/catch による集約 =====
async function processOrder(orderId) {
    try {
        const order = await fetchOrder(orderId);
        const payment = await processPayment(order);
        const shipping = await arrangeShipping(order, payment);
        await sendConfirmationEmail(order, shipping);
        return { success: true, trackingNumber: shipping.trackingNumber };
    } catch (error) {
        // エラーの種類に応じた処理
        if (error instanceof PaymentError) {
            await refundIfNeeded(orderId);
            return { success: false, reason: 'payment_failed' };
        }
        if (error instanceof ShippingError) {
            await notifyManualReview(orderId, error);
            return { success: false, reason: 'shipping_unavailable' };
        }
        // 予期しないエラーは再 throw
        throw error;
    }
}
 
// ===== パターン2: Result 型パターン（Go風エラーハンドリング） =====
async function safeAsync(asyncFn) {
    try {
        const result = await asyncFn();
        return [result, null];
    } catch (error) {
        return [null, error];
    }
}
 
// 使用例
async function loadUserData(userId) {
    const [user, userErr] = await safeAsync(() => fetchUser(userId));
    if (userErr) {
        console.error('User fetch failed:', userErr);
        return null;
    }
 
    const [posts, postsErr] = await safeAsync(() => fetchPosts(user.id));
    if (postsErr) {
        console.warn('Posts fetch failed, continuing without posts');
    }
 
    return { user, posts: posts || [] };
}
 
// ===== パターン3: AbortController によるキャンセル =====
class ApiClient {
    constructor() {
        this.controllers = new Map();
    }
 
    async fetch(key, url, options = {}) {
        // 既存のリクエストをキャンセル
        if (this.controllers.has(key)) {
            this.controllers.get(key).abort();
        }
 
        const controller = new AbortController();
        this.controllers.set(key, controller);
 
        try {
            const response = await fetch(url, {
                ...options,
                signal: controller.signal,
            });
            return await response.json();
        } catch (error) {
            if (error.name === 'AbortError') {
                console.log(`Request ${key} was cancelled`);
                return null;
            }
            throw error;
        } finally {
            this.controllers.delete(key);
        }
    }
 
    cancelAll() {
        for (const controller of this.controllers.values()) {
            controller.abort();
        }
        this.controllers.clear();
    }
}

// ===== for await...of: 非同期データストリームの逐次処理 =====
 
// 非同期ジェネレータ関数
async function* fetchPages(baseUrl) {
    let page = 1;
    let hasMore = true;
 
    while (hasMore) {
        const response = await fetch(`${baseUrl}?page=${page}`);
        const data = await response.json();
 
        yield data.items;
 
        hasMore = data.hasNextPage;
        page++;
    }
}
 
// 使用例: ページネーションの全データを処理
async function processAllItems(baseUrl) {
    const allItems = [];
 
    for await (const items of fetchPages(baseUrl)) {
        allItems.push(...items);
        console.log(`Processed page, total items: ${allItems.length}`);
    }
 
    return allItems;
}
 
// ReadableStream からの読み取り（Web Streams API）
async function readStream(response) {
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let result = '';
 
    while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        result += decoder.decode(value, { stream: true });
    }
 
    return result;
}

import asyncio
from typing import Any
 
# ===== コルーチン関数: async def で定義 =====
async def fetch_data(url: str) -> dict:
    """非同期にデータを取得する"""
    # コルーチン関数を呼び出すとコルーチンオブジェクトが返る
    # await するまで実行されない
    await asyncio.sleep(1)  # I/O 操作のシミュレーション
    return {"url": url, "data": "sample"}
 
# ===== コルーチンの実行方法 =====
 
# 方法1: asyncio.run()（メインエントリポイント）
async def main():
    result = await fetch_data("https://api.example.com/data")
    print(result)
 
asyncio.run(main())
 
# 方法2: イベントループを直接操作（低レベル）
loop = asyncio.get_event_loop()
result = loop.run_until_complete(fetch_data("https://api.example.com"))
loop.close()

import asyncio
import aiohttp
from dataclasses import dataclass
 
@dataclass
class UserDashboard:
    user: dict
    posts: list
    notifications: list
 
async def fetch_json(session: aiohttp.ClientSession, url: str) -> Any:
    """汎用的な JSON フェッチ関数"""
    async with session.get(url) as response:
        response.raise_for_status()
        return await response.json()
 
# ===== asyncio.gather: 並行実行（最も一般的） =====
async def load_dashboard(user_id: int) -> UserDashboard:
    async with aiohttp.ClientSession() as session:
        base = "https://api.example.com"
        user, posts, notifications = await asyncio.gather(
            fetch_json(session, f"{base}/users/{user_id}"),
            fetch_json(session, f"{base}/users/{user_id}/posts"),
            fetch_json(session, f"{base}/users/{user_id}/notifications"),
        )
        return UserDashboard(user=user, posts=posts, notifications=notifications)
 
# ===== asyncio.gather: return_exceptions=True で例外もキャッチ =====
async def load_dashboard_safe(user_id: int) -> dict:
    async with aiohttp.ClientSession() as session:
        base = "https://api.example.com"
        results = await asyncio.gather(
            fetch_json(session, f"{base}/users/{user_id}"),
            fetch_json(session, f"{base}/users/{user_id}/posts"),
            fetch_json(session, f"{base}/users/{user_id}/notifications"),
            return_exceptions=True,  # 例外を値として返す
        )
        return {
            "user": results[0] if not isinstance(results[0], Exception) else None,
            "posts": results[1] if not isinstance(results[1], Exception) else [],
            "notifications": results[2] if not isinstance(results[2], Exception) else [],
        }
 
# ===== TaskGroup: 構造化並行性（Python 3.11+） =====
async def load_dashboard_structured(user_id: int) -> UserDashboard:
    """TaskGroup を使った構造化並行性パターン"""
    results = {}
 
    async with aiohttp.ClientSession() as session:
        base = "https://api.example.com"
 
        async with asyncio.TaskGroup() as tg:
            async def fetch_and_store(key: str, url: str):
                results[key] = await fetch_json(session, url)
 
            tg.create_task(fetch_and_store("user", f"{base}/users/{user_id}"))
            tg.create_task(fetch_and_store("posts", f"{base}/users/{user_id}/posts"))
            tg.create_task(fetch_and_store("notifs", f"{base}/users/{user_id}/notifications"))
 
        # TaskGroup の外に到達 = 全タスク完了
        # いずれかが例外を投げた場合、他の全タスクがキャンセルされ
        # ExceptionGroup として集約される
 
    return UserDashboard(
        user=results["user"],
        posts=results["posts"],
        notifications=results["notifs"],
    )

import asyncio
 
# ===== asyncio.timeout: タイムアウト制御（Python 3.11+） =====
async def fetch_with_timeout(url: str, timeout_sec: float = 5.0):
    try:
        async with asyncio.timeout(timeout_sec):
            return await fetch_data(url)
    except TimeoutError:
        print(f"Timeout after {timeout_sec}s: {url}")
        return None
 
# ===== asyncio.wait_for: 従来のタイムアウト方式 =====
async def fetch_with_wait_for(url: str, timeout_sec: float = 5.0):
    try:
        return await asyncio.wait_for(
            fetch_data(url),
            timeout=timeout_sec,
        )
    except asyncio.TimeoutError:
        print(f"Timeout: {url}")
        return None
 
# ===== タスクのキャンセル =====
async def cancellable_operation():
    task = asyncio.create_task(long_running_operation())
 
    # 5秒後にキャンセル
    await asyncio.sleep(5)
    task.cancel()
 
    try:
        await task
    except asyncio.CancelledError:
        print("タスクがキャンセルされました")
 
# ===== セマフォによる同時実行数制限 =====
async def fetch_many_urls(urls: list[str], max_concurrent: int = 10):
    """同時接続数を制限しながら大量の URL をフェッチ"""
    semaphore = asyncio.Semaphore(max_concurrent)
    results = []
 
    async def limited_fetch(url: str):
        async with semaphore:  # 同時実行数を max_concurrent に制限
            return await fetch_data(url)
 
    results = await asyncio.gather(
        *[limited_fetch(url) for url in urls]
    )
    return results

import asyncio
from contextlib import asynccontextmanager
 
# ===== 非同期コンテキストマネージャ =====
class AsyncDatabaseConnection:
    """非同期データベース接続の例"""
 
    async def __aenter__(self):
        self.conn = await create_connection()
        return self
 
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.conn.close()
        return False  # 例外を伝播
 
    async def query(self, sql: str):
        return await self.conn.execute(sql)
 
# 使用例
async def get_users():
    async with AsyncDatabaseConnection() as db:
        return await db.query("SELECT * FROM users")
 
# ===== デコレータ方式 =====
@asynccontextmanager
async def managed_resource(name: str):
    resource = await acquire_resource(name)
    try:
        yield resource
    finally:
        await release_resource(resource)
 
# ===== 非同期イテレータ =====
class AsyncPaginator:
    """ページネーション付き非同期イテレータ"""
 
    def __init__(self, base_url: str, page_size: int = 20):
        self.base_url = base_url
        self.page_size = page_size
        self.current_page = 0
 
    def __aiter__(self):
        return self
 
    async def __anext__(self):
        self.current_page += 1
        data = await fetch_data(
            f"{self.base_url}?page={self.current_page}&size={self.page_size}"
        )
        if not data.get("items"):
            raise StopAsyncIteration
        return data["items"]
 
# 使用例
async def process_all_users():
    async for page in AsyncPaginator("https://api.example.com/users"):
        for user in page:
            await process_user(user)
 
# ===== 非同期ジェネレータ =====
async def event_stream(url: str):
    """Server-Sent Events を受信する非同期ジェネレータ"""
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            async for line in response.content:
                decoded = line.decode('utf-8').strip()
                if decoded.startswith('data:'):
                    yield decoded[5:].strip()

// ===== Future トレイトの定義（標準ライブラリ） =====
pub trait Future {
    type Output;
 
    // poll が呼ばれるたびに進捗をチェック
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}
 
pub enum Poll<T> {
    Ready(T),    // 完了: 値が利用可能
    Pending,     // 未完了: まだ待機中
}
 
// ===== 手動で Future を実装する例 =====
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::{Duration, Instant};
 
struct Delay {
    when: Instant,
}
 
impl Delay {
    fn new(duration: Duration) -> Self {
        Delay {
            when: Instant::now() + duration,
        }
    }
}
 
impl Future for Delay {
    type Output = ();
 
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        if Instant::now() >= self.when {
            Poll::Ready(())
        } else {
            // ウェイカーを登録して、後で再ポーリングを要求
            let waker = cx.waker().clone();
            let when = self.when;
            std::thread::spawn(move || {
                let now = Instant::now();
                if now < when {
                    std::thread::sleep(when - now);
                }
                waker.wake();  // ランタイムに再ポーリングを通知
            });
            Poll::Pending
        }
    }
}
 
// 使用
async fn example() {
    println!("開始");
    Delay::new(Duration::from_secs(2)).await;
    println!("2秒経過");
}

use tokio;
use tokio::time::{sleep, timeout, Duration};
use tokio::sync::{mpsc, Semaphore};
use std::sync::Arc;
 
// ===== 基本的な async main =====
#[tokio::main]
async fn main() {
    let result = fetch_data("https://api.example.com").await;
    match result {
        Ok(data) => println!("Data: {}", data),
        Err(e) => eprintln!("Error: {}", e),
    }
}
 
// ===== 並行実行パターン =====
async fn load_dashboard(user_id: u32) -> Result<Dashboard, AppError> {
    // tokio::join!: 全て並行実行して全完了を待つ
    let (user_result, posts_result, notifs_result) = tokio::join!(
        fetch_user(user_id),
        fetch_posts(user_id),
        fetch_notifications(user_id),
    );
 
    Ok(Dashboard {
        user: user_result?,
        posts: posts_result?,
        notifications: notifs_result?,
    })
}
 
// ===== tokio::select!: 最初に完了したものを処理 =====
async fn fetch_with_fallback(primary: &str, fallback: &str) -> String {
    tokio::select! {
        result = fetch_data(primary) => {
            match result {
                Ok(data) => data,
                Err(_) => fetch_data(fallback).await.unwrap_or_default(),
            }
        }
        _ = sleep(Duration::from_secs(3)) => {
            // プライマリがタイムアウト → フォールバック
            fetch_data(fallback).await.unwrap_or_default()
        }
    }
}
 
// ===== タスクスポーン: バックグラウンド実行 =====
async fn spawn_example() {
    let handle = tokio::spawn(async {
        // 別タスクとして非同期実行
        heavy_computation().await
    });
 
    // 他の処理を並行して実行
    do_other_work().await;
 
    // タスクの結果を取得
    let result = handle.await.expect("Task panicked");
    println!("Result: {:?}", result);
}
 
// ===== セマフォによる同時実行数制限 =====
async fn fetch_many_urls(urls: Vec<String>) -> Vec<Result<String, reqwest::Error>> {
    let semaphore = Arc::new(Semaphore::new(10)); // 最大10並行
    let mut handles = vec![];
 
    for url in urls {
        let permit = semaphore.clone().acquire_owned().await.unwrap();
        let handle = tokio::spawn(async move {
            let result = reqwest::get(&url).await?.text().await;
            drop(permit); // 明示的にセマフォを解放
            result
        });
        handles.push(handle);
    }
 
    let mut results = vec![];
    for handle in handles {
        results.push(handle.await.unwrap());
    }
    results
}

use tokio_stream::{self as stream, StreamExt};
 
// ===== Stream: 非同期イテレータ =====
async fn process_stream() {
    let mut stream = stream::iter(vec![1, 2, 3, 4, 5])
        .map(|x| async move {
            sleep(Duration::from_millis(100)).await;
            x * 2
        })
        .buffered(3); // 最大3つを並行処理
 
    while let Some(value) = stream.next().await {
        println!("Value: {}", value);
    }
}
 
// ===== チャネルベースのストリーム =====
async fn event_producer(tx: mpsc::Sender<String>) {
    for i in 0..100 {
        tx.send(format!("Event {}", i)).await.unwrap();
        sleep(Duration::from_millis(10)).await;
    }
}
 
async fn event_consumer(mut rx: mpsc::Receiver<String>) {
    while let Some(event) = rx.recv().await {
        println!("Received: {}", event);
    }
}
 
async fn channel_example() {
    let (tx, rx) = mpsc::channel(32); // バッファサイズ 32
 
    tokio::spawn(event_producer(tx));
    event_consumer(rx).await;
}

package main
 
import (
    "fmt"
    "net/http"
    "sync"
    "time"
    "context"
    "encoding/json"
    "io"
)
 
// ===== goroutine: go キーワードで軽量スレッドを起動 =====
func fetchURL(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
 
func main() {
    // 通常の関数呼び出し（同期）
    data, _ := fetchURL("https://api.example.com/data")
    fmt.Println(string(data))
 
    // goroutine で非同期実行
    go func() {
        data, _ := fetchURL("https://api.example.com/other")
        fmt.Println(string(data))
    }()
 
    // goroutine が完了する前に main が終了しないよう待機
    time.Sleep(2 * time.Second)
}

// ===== channel: goroutine 間の通信チャネル =====
 
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}
 
func fetchUser(id int, ch chan<- User) {
    resp, err := http.Get(fmt.Sprintf("https://api.example.com/users/%d", id))
    if err != nil {
        return
    }
    defer resp.Body.Close()
 
    var user User
    json.NewDecoder(resp.Body).Decode(&user)
    ch <- user // チャネルに送信
}
 
func main() {
    ch := make(chan User, 3) // バッファ付きチャネル
 
    // 3つの goroutine を並行起動
    for i := 1; i <= 3; i++ {
        go fetchUser(i, ch)
    }
 
    // 3つの結果を収集
    users := make([]User, 0, 3)
    for i := 0; i < 3; i++ {
        user := <-ch // チャネルから受信
        users = append(users, user)
    }
    fmt.Println(users)
}
 
// ===== select: 複数チャネルの多重化 =====
func fetchWithTimeout(url string, timeout time.Duration) ([]byte, error) {
    resultCh := make(chan []byte, 1)
    errCh := make(chan error, 1)
 
    go func() {
        data, err := fetchURL(url)
        if err != nil {
            errCh <- err
            return
        }
        resultCh <- data
    }()
 
    select {
    case data := <-resultCh:
        return data, nil
    case err := <-errCh:
        return nil, err
    case <-time.After(timeout):
        return nil, fmt.Errorf("timeout after %v", timeout)
    }
}
 
// ===== WaitGroup: goroutine の完了を待機 =====
func fetchMultipleURLs(urls []string) map[string][]byte {
    var mu sync.Mutex
    var wg sync.WaitGroup
    results := make(map[string][]byte)
 
    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            data, err := fetchURL(u)
            if err != nil {
                return
            }
            mu.Lock()
            results[u] = data
            mu.Unlock()
        }(url)
    }
 
    wg.Wait() // 全 goroutine の完了を待機
    return results
}
 
// ===== context: キャンセルとタイムアウト =====
func fetchWithContext(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }
 
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
 
func main() {
    // 5秒のタイムアウト付きコンテキスト
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
 
    data, err := fetchWithContext(ctx, "https://api.example.com/data")
    if err != nil {
        if ctx.Err() == context.DeadlineExceeded {
            fmt.Println("リクエストがタイムアウトしました")
        }
        return
    }
    fmt.Println(string(data))
}

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
 
// ===== 基本的な async/await =====
public class ApiClient
{
    private readonly HttpClient _httpClient = new HttpClient();
 
    public async Task<string> FetchDataAsync(string url)
    {
        // await: Task の完了を非同期に待機
        HttpResponseMessage response = await _httpClient.GetAsync(url);
        response.EnsureSuccessStatusCode();
        string content = await response.Content.ReadAsStringAsync();
        return content;
    }
 
    // ===== 並行実行: Task.WhenAll =====
    public async Task<Dashboard> LoadDashboardAsync(int userId)
    {
        // 3つのタスクを同時に開始
        Task<User> userTask = FetchUserAsync(userId);
        Task<List<Post>> postsTask = FetchPostsAsync(userId);
        Task<List<Notification>> notifsTask = FetchNotificationsAsync(userId);
 
        // 全タスクの完了を待機
        await Task.WhenAll(userTask, postsTask, notifsTask);
 
        return new Dashboard
        {
            User = userTask.Result,
            Posts = postsTask.Result,
            Notifications = notifsTask.Result,
        };
    }
 
    // ===== CancellationToken: キャンセル制御 =====
    public async Task<string> FetchWithCancellationAsync(
        string url,
        CancellationToken cancellationToken)
    {
        try
        {
            HttpResponseMessage response = await _httpClient.GetAsync(
                url, cancellationToken);
            return await response.Content.ReadAsStringAsync(cancellationToken);
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("リクエストがキャンセルされました");
            return null;
        }
    }
 
    // ===== タイムアウト付きリクエスト =====
    public async Task<string> FetchWithTimeoutAsync(
        string url, TimeSpan timeout)
    {
        using var cts = new CancellationTokenSource(timeout);
        return await FetchWithCancellationAsync(url, cts.Token);
    }
}
 
// ===== IAsyncEnumerable: 非同期ストリーム（C# 8.0+） =====
public class PaginatedApi
{
    public async IAsyncEnumerable<List<Item>> FetchAllPagesAsync(
        string baseUrl,
        [EnumeratorCancellation] CancellationToken ct = default)
    {
        int page = 1;
        bool hasMore = true;
 
        while (hasMore && !ct.IsCancellationRequested)
        {
            var response = await FetchPageAsync($"{baseUrl}?page={page}", ct);
            yield return response.Items;
            hasMore = response.HasNextPage;
            page++;
        }
    }
}
 
// 使用例
await foreach (var items in api.FetchAllPagesAsync("/api/items"))
{
    foreach (var item in items)
    {
        await ProcessItemAsync(item);
    }
}

import java.net.http.*;
import java.net.URI;
import java.time.Duration;
import java.util.concurrent.*;
import java.util.List;
import java.util.stream.Collectors;
 
// ===== Virtual Threads: 軽量スレッド（Java 21+） =====
public class AsyncJavaExample {
 
    private static final HttpClient client = HttpClient.newHttpClient();
 
    public static String fetchData(String url) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .timeout(Duration.ofSeconds(10))
            .build();
 
        HttpResponse<String> response = client.send(
            request, HttpResponse.BodyHandlers.ofString());
        return response.body();
    }
 
    public static void main(String[] args) throws Exception {
        // ===== 方法1: Virtual Thread を直接起動 =====
        Thread vThread = Thread.ofVirtual().start(() -> {
            try {
                String data = fetchData("https://api.example.com/data");
                System.out.println(data);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        vThread.join();
 
        // ===== 方法2: ExecutorService + Virtual Threads =====
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = List.of(
                executor.submit(() -> fetchData("https://api.example.com/users")),
                executor.submit(() -> fetchData("https://api.example.com/posts")),
                executor.submit(() -> fetchData("https://api.example.com/notifications"))
            );
 
            for (Future<String> future : futures) {
                System.out.println(future.get()); // 結果取得
            }
        }
 
        // ===== 方法3: StructuredTaskScope（Structured Concurrency Preview） =====
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Future<String> users = scope.fork(() ->
                fetchData("https://api.example.com/users"));
            Future<String> posts = scope.fork(() ->
                fetchData("https://api.example.com/posts"));
 
            scope.join();           // 全タスクの完了を待機
            scope.throwIfFailed();  // いずれか失敗なら例外
 
            System.out.println(users.resultNow());
            System.out.println(posts.resultNow());
        }
    }
}
 
// ===== CompletableFuture: 従来の非同期API =====
public class CompletableFutureExample {
 
    public static CompletableFuture<String> fetchAsync(String url) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return fetchData(url);
            } catch (Exception e) {
                throw new CompletionException(e);
            }
        });
    }
 
    public static void main(String[] args) {
        // チェーン: thenApply, thenCompose, thenCombine
        CompletableFuture<String> future = fetchAsync("/api/users/1")
            .thenApply(json -> parseUser(json))        // 変換
            .thenCompose(user -> fetchAsync(            // 次の非同期処理
                "/api/posts?userId=" + user.getId()))
            .exceptionally(ex -> {                     // エラー処理
                System.err.println("Error: " + ex.getMessage());
                return "[]";
            });
 
        // 並行実行: allOf
        CompletableFuture<Void> all = CompletableFuture.allOf(
            fetchAsync("/api/users"),
            fetchAsync("/api/posts"),
            fetchAsync("/api/notifications")
        );
        all.join(); // 全完了を待機
    }
}

// ===== BAD: 逐次 await（不必要に遅い） =====
async function loadPageData(userId) {
    // これら3つの処理は互いに依存しないが、直列に実行される
    const user = await fetchUser(userId);        // 200ms 待ち
    const posts = await fetchPosts(userId);       // 300ms 待ち
    const notifications = await fetchNotifications(userId); // 150ms 待ち
    // 合計: 200 + 300 + 150 = 650ms
 
    return { user, posts, notifications };
}
 
// ===== GOOD: 並行 await（高速） =====
async function loadPageData(userId) {
    // Promise.all で並行実行
    const [user, posts, notifications] = await Promise.all([
        fetchUser(userId),        // ─┐
        fetchPosts(userId),       // ─┤ 並行実行
        fetchNotifications(userId), // ─┘
    ]);
    // 合計: max(200, 300, 150) = 300ms（約54%高速化）
 
    return { user, posts, notifications };
}
 
// ===== BEST: 依存関係を考慮した最適化 =====
async function loadPageData(userId) {
    // Step 1: user は他の処理に必要なので先に取得
    const user = await fetchUser(userId);
 
    // Step 2: posts と notifications は並行可能
    const [posts, notifications] = await Promise.all([
        fetchPosts(user.id),
        fetchNotifications(user.id),
    ]);
 
    // Step 3: comments は posts に依存
    const comments = await fetchComments(posts[0]?.id);
 
    return { user, posts, notifications, comments };
}

// ===== BAD: Promise と async/await の混在による混乱 =====
async function processData() {
    // .then() 内で await を使おうとする（エラーにはならないが紛らわしい）
    const result = fetch('/api/data')
        .then(async (response) => {
            const json = await response.json();
            const processed = await processJson(json);
            return processed;
        })
        .catch(err => {
            console.error(err);
            return null;
        });
 
    return result; // これは Promise<Promise<...>> になりうる
}
 
// ===== GOOD: async/await で統一 =====
async function processData() {
    try {
        const response = await fetch('/api/data');
        const json = await response.json();
        const processed = await processJson(json);
        return processed;
    } catch (err) {
        console.error(err);
        return null;
    }
}

// ===== BAD: await なしで非同期関数を呼ぶ =====
async function handleRequest(req, res) {
    const data = await fetchData(req.params.id);
 
    // ログ記録を非同期で呼ぶが、await していない
    saveAuditLog(req.user, 'data_access');  // ← Promise が浮遊
 
    // 問題1: エラーが捕捉されない（Unhandled Promise Rejection）
    // 問題2: プロセス終了時にログが失われる可能性
    // 問題3: デバッグが困難
 
    res.json(data);
}
 
// ===== GOOD: 意図的な Fire-and-Forget には明示的にエラー処理 =====
async function handleRequest(req, res) {
    const data = await fetchData(req.params.id);
 
    // 方法1: catch で明示的にエラーを処理
    saveAuditLog(req.user, 'data_access')
        .catch(err => console.error('Audit log failed:', err));
 
    // 方法2: void 演算子で意図的であることを明示
    void saveAuditLog(req.user, 'data_access')
        .catch(err => console.error('Audit log failed:', err));
 
    res.json(data);
}
 
// ===== BEST: バックグラウンドタスクキューを使う =====
async function handleRequest(req, res) {
    const data = await fetchData(req.params.id);
 
    // タスクキューに投入（リトライ・監視付き）
    backgroundQueue.enqueue('audit_log', {
        user: req.user,
        action: 'data_access',
        timestamp: Date.now(),
    });
 
    res.json(data);
}

import asyncio
import time
 
# ===== BAD: async 関数内で同期的にブロック =====
async def process_data():
    data = await fetch_data()
 
    # time.sleep はイベントループをブロックする!
    time.sleep(5)  # ← 全ての非同期処理が5秒間停止
 
    # CPU密集処理もイベントループをブロック
    result = heavy_computation(data)  # ← 計算中は他の処理が進まない
 
    return result
 
# ===== GOOD: 非同期スリープとスレッドプールを使う =====
async def process_data():
    data = await fetch_data()
 
    # asyncio.sleep は他の処理をブロックしない
    await asyncio.sleep(5)
 
    # CPU密集処理はスレッドプールで実行
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, heavy_computation, data)
 
    return result

# ===== BAD: 同期コード内から asyncio.run() をネスト呼び出し =====
import asyncio
 
async def inner():
    return "result"
 
async def outer():
    # 既にイベントループが動作中に asyncio.run() を呼ぶとデッドロック
    result = asyncio.run(inner())  # RuntimeError!
    return result
 
# ===== GOOD: await を使う =====
async def outer():
    result = await inner()  # 正しい方法
    return result

// ===== BAD: C# での .Result / .Wait() によるデッドロック =====
// ASP.NET / WPF など SynchronizationContext がある環境で危険
public string GetData()
{
    // async メソッドを .Result で同期的に待機
    // → SynchronizationContext のキャプチャによりデッドロック
    var result = FetchDataAsync().Result;  // ← デッドロック!
    return result;
}
 
// ===== GOOD: async を末端まで伝播させる =====
public async Task<string> GetDataAsync()
{
    var result = await FetchDataAsync();  // 正しい
    return result;
}
 
// ConfigureAwait(false) で SynchronizationContext を無視
public async Task<string> GetDataAsync()
{
    var result = await FetchDataAsync().ConfigureAwait(false);
    return result;
}

// ===== 指数バックオフ付きリトライ =====
async function fetchWithRetry(url, options = {}) {
    const {
        maxRetries = 3,
        baseDelay = 1000,    // 初回待機: 1秒
        maxDelay = 30000,    // 最大待機: 30秒
        backoffFactor = 2,   // 倍率
        retryableStatuses = [408, 429, 500, 502, 503, 504],
    } = options;
 
    let lastError;
 
    for (let attempt = 0; attempt <= maxRetries; attempt++) {
        try {
            const response = await fetch(url);
 
            if (response.ok) {
                return await response.json();
            }
 
            if (!retryableStatuses.includes(response.status)) {
                throw new Error(`Non-retryable HTTP ${response.status}`);
            }
 
            lastError = new Error(`HTTP ${response.status}`);
        } catch (error) {
            lastError = error;
 
            if (error.name === 'AbortError') {
                throw error; // キャンセルはリトライしない
            }
        }
 
        if (attempt < maxRetries) {
            // 指数バックオフ + ジッタ
            const delay = Math.min(
                baseDelay * Math.pow(backoffFactor, attempt),
                maxDelay
            );
            const jitter = delay * (0.5 + Math.random() * 0.5);
 
            console.log(
                `Retry ${attempt + 1}/${maxRetries} after ${Math.round(jitter)}ms`
            );
            await new Promise(resolve => setTimeout(resolve, jitter));
        }
    }
 
    throw lastError;
}
 
// 使用例
const data = await fetchWithRetry('https://api.example.com/data', {
    maxRetries: 5,
    baseDelay: 500,
});

// ===== サーキットブレーカー: 障害の連鎖を防ぐ =====
class CircuitBreaker {
    constructor(options = {}) {
        this.failureThreshold = options.failureThreshold || 5;
        this.resetTimeout = options.resetTimeout || 60000; // 60秒
        this.state = 'CLOSED';  // CLOSED → OPEN → HALF_OPEN → CLOSED
        this.failureCount = 0;
        this.lastFailureTime = null;
        this.successCount = 0;
    }
 
    async execute(asyncFn) {
        if (this.state === 'OPEN') {
            if (Date.now() - this.lastFailureTime > this.resetTimeout) {
                this.state = 'HALF_OPEN';
                this.successCount = 0;
            } else {
                throw new Error('Circuit breaker is OPEN');
            }
        }
 
        try {
            const result = await asyncFn();
            this._onSuccess();
            return result;
        } catch (error) {
            this._onFailure();
            throw error;
        }
    }
 
    _onSuccess() {
        if (this.state === 'HALF_OPEN') {
            this.successCount++;
            if (this.successCount >= 3) {
                this.state = 'CLOSED';
                this.failureCount = 0;
            }
        } else {
            this.failureCount = 0;
        }
    }
 
    _onFailure() {
        this.failureCount++;
        this.lastFailureTime = Date.now();
        if (this.failureCount >= this.failureThreshold) {
            this.state = 'OPEN';
        }
    }
}
 
// 使用例
const breaker = new CircuitBreaker({
    failureThreshold: 5,
    resetTimeout: 30000,
});
 
async function callExternalService() {
    return breaker.execute(async () => {
        const response = await fetch('https://external-api.example.com/data');
        if (!response.ok) throw new Error(`HTTP ${response.status}`);
        return response.json();
    });
}

import asyncio
 
class BulkheadExecutor:
    """
    バルクヘッドパターン: サービスごとに同時実行数を分離し、
    1つのサービス障害が他のサービスに波及するのを防ぐ
    """
 
    def __init__(self):
        self.semaphores = {}
 
    def register(self, service_name: str, max_concurrent: int):
        """サービスごとの同時実行数上限を登録"""
        self.semaphores[service_name] = asyncio.Semaphore(max_concurrent)
 
    async def execute(self, service_name: str, coro):
        """指定サービスのバルクヘッド内で非同期処理を実行"""
        sem = self.semaphores.get(service_name)
        if sem is None:
            raise ValueError(f"Unknown service: {service_name}")
 
        async with sem:
            return await coro
 
# 使用例
bulkhead = BulkheadExecutor()
bulkhead.register("user_service", max_concurrent=20)
bulkhead.register("payment_service", max_concurrent=5)   # 少なめに制限
bulkhead.register("notification_service", max_concurrent=50)
 
async def handle_order(order_id: int):
    user = await bulkhead.execute(
        "user_service", fetch_user(order_id)
    )
    payment = await bulkhead.execute(
        "payment_service", process_payment(order_id)
    )
    await bulkhead.execute(
        "notification_service", send_notification(user, payment)
    )

// 解答テンプレート
async function fetchAllUsers(userIds) {
    // ここに実装
}
 
// テスト
// const users = await fetchAllUsers([1, 2, 3, 4, 5]);
// console.log(users); // [{id:1,name:"Alice"}, {id:2,...}, ...]