/* thread_basics.c - スレッドの基本操作を示す完全な例
 *
 * コンパイル: gcc -Wall -pthread -o thread_basics thread_basics.c
 * 実行:       ./thread_basics
 *
 * なぜ -pthread フラグが必要か:
 *   リンカに libpthread をリンクするよう指示する。
 *   pthreads の関数（pthread_create 等）はこのライブラリに含まれている。
 *   -lpthread でも動作するが、-pthread の方がコンパイラフラグも設定するため推奨。
 */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
 
/* スレッドに渡す引数構造体 */
typedef struct {
    int thread_id;
    int iterations;
} thread_arg_t;
 
/*
 * スレッドのエントリポイント関数。
 * 引数: void* 型で受け取り、内部でキャストする（POSIX APIの規約）。
 * 戻り値: void* 型で返し、pthread_join() で受け取れる。
 *
 * なぜ void* なのか:
 *   型安全性を犠牲にする代わりに、任意の型のデータを渡せる
 *   汎用性を実現するためのC言語的設計。
 */
void* worker(void* arg) {
    thread_arg_t* targ = (thread_arg_t*)arg;
    printf("Thread %d: 開始 (iterations=%d)\n", targ->thread_id, targ->iterations);
 
    long sum = 0;
    for (int i = 0; i < targ->iterations; i++) {
        sum += i;
    }
 
    printf("Thread %d: 完了 (sum=%ld)\n", targ->thread_id, sum);
 
    /* ヒープに戻り値を確保して返す。
     * スタック上のローカル変数を返してはならない。
     * なぜなら、スレッド終了後にスタックは解放されるため。 */
    long* result = malloc(sizeof(long));
    if (result == NULL) {
        perror("malloc");
        return NULL;
    }
    *result = sum;
    return (void*)result;
}
 
int main(void) {
    const int NUM_THREADS = 4;
    pthread_t threads[NUM_THREADS];
    thread_arg_t args[NUM_THREADS];
 
    printf("メインスレッド: %d個のワーカースレッドを生成\n", NUM_THREADS);
 
    /* スレッド生成 */
    for (int i = 0; i < NUM_THREADS; i++) {
        args[i].thread_id = i;
        args[i].iterations = (i + 1) * 1000000;
 
        /*
         * pthread_create の引数:
         *   1. &threads[i]  - スレッドIDを格納する変数
         *   2. NULL         - スレッド属性（NULLでデフォルト）
         *   3. worker       - スレッドが実行する関数
         *   4. &args[i]     - 関数に渡す引数
         *
         * 戻り値: 0なら成功、非0ならエラーコード
         */
        int ret = pthread_create(&threads[i], NULL, worker, &args[i]);
        if (ret != 0) {
            fprintf(stderr, "pthread_create failed: %d\n", ret);
            exit(EXIT_FAILURE);
        }
    }
 
    /* 全スレッドの完了を待機（join） */
    for (int i = 0; i < NUM_THREADS; i++) {
        void* retval;
        /*
         * pthread_join はスレッドの終了を待ち、戻り値を受け取る。
         * なぜ join が必要か:
         *   1. スレッドの完了を保証する（結果の利用前に）
         *   2. スレッドのリソース（TCB等）を解放する
         *   join しないスレッドはゾンビ状態になり、リソースリークの原因となる。
         */
        int ret = pthread_join(threads[i], &retval);
        if (ret != 0) {
            fprintf(stderr, "pthread_join failed: %d\n", ret);
            exit(EXIT_FAILURE);
        }
        if (retval != NULL) {
            printf("メインスレッド: Thread %d の結果 = %ld\n", i, *(long*)retval);
            free(retval);  /* worker() で malloc したメモリを解放 */
        }
    }
 
    printf("メインスレッド: 全スレッド完了\n");
    return 0;
}

/* JavaThreadDemo.java - Java のスレッド基本操作
 *
 * コンパイル・実行: javac JavaThreadDemo.java && java JavaThreadDemo
 *
 * Java のスレッドは長年 1:1 モデル（OS スレッドと直接対応）であった。
 * Java 21 (2023) で Virtual Threads が正式導入され、M:N モデルに移行した。
 */
 
import java.util.ArrayList;
import java.util.List;
 
public class JavaThreadDemo {
 
    /* 共有カウンタ: volatile だけでは不十分な理由を示す */
    private static int counter = 0;
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        System.out.println("=== Platform Threads (従来の 1:1 スレッド) ===");
        platformThreadDemo();
 
        System.out.println("\n=== Virtual Threads (Java 21+ の M:N スレッド) ===");
        virtualThreadDemo();
    }
 
    static void platformThreadDemo() throws InterruptedException {
        counter = 0;
        List<Thread> threads = new ArrayList<>();
 
        for (int i = 0; i < 4; i++) {
            final int id = i;
            /*
             * Thread.ofPlatform() は Java 21+ の新しいAPI。
             * 従来の new Thread() と同等だが、設定が宣言的に書ける。
             * 内部では OS の pthread_create() が呼ばれる。
             */
            Thread t = Thread.ofPlatform()
                .name("worker-" + id)
                .start(() -> {
                    for (int j = 0; j < 100_000; j++) {
                        /*
                         * synchronized ブロック: Java の組み込み Mutex。
                         * モニターロックとも呼ばれ、JVM が管理する。
                         * なぜ synchronized が必要か:
                         *   counter++ は read-modify-write の3ステップであり、
                         *   アトミックではないため、保護なしでは競合状態が発生する。
                         */
                        synchronized (lock) {
                            counter++;
                        }
                    }
                });
            threads.add(t);
        }
 
        for (Thread t : threads) {
            t.join(); /* スレッドの完了を待機 */
        }
 
        System.out.println("Counter = " + counter + " (期待値: 400000)");
    }
 
    static void virtualThreadDemo() throws InterruptedException {
        counter = 0;
        List<Thread> threads = new ArrayList<>();
 
        for (int i = 0; i < 10_000; i++) {
            /*
             * Thread.ofVirtual(): Java 21 の Virtual Threads。
             * OS スレッドではなく、JVM が管理する軽量スレッド。
             * Go の goroutine と同様の M:N モデルで動作する。
             *
             * なぜ Virtual Threads が導入されたか:
             *   OS スレッドは1つあたり ~1MB のスタックを消費するため、
             *   数万スレッドの生成は非現実的だった。
             *   Virtual Threads は ~1KB から開始し、必要に応じて拡張される。
             */
            Thread t = Thread.ofVirtual()
                .start(() -> {
                    synchronized (lock) {
                        counter++;
                    }
                });
            threads.add(t);
        }
 
        for (Thread t : threads) {
            t.join();
        }
 
        System.out.println("Counter = " + counter + " (期待値: 10000)");
        System.out.println("10,000 Virtual Threads を生成・完了");
    }
}

/* mutex_demo.c - Mutex による競合状態の防止
 *
 * コンパイル: gcc -Wall -pthread -o mutex_demo mutex_demo.c
 * 実行:       ./mutex_demo
 */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
#define NUM_THREADS  4
#define ITERATIONS   1000000
 
/* 共有カウンタとMutex */
static long counter_unsafe = 0;
static long counter_safe   = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
/*
 * PTHREAD_MUTEX_INITIALIZER はスタティック初期化マクロ。
 * 動的初期化の pthread_mutex_init() と同等だが、
 * グローバル/static変数にのみ使用可能。
 * なぜ便利か: init/destroy の呼び出しが不要でコードが簡潔になる。
 */
 
void* unsafe_worker(void* arg) {
    (void)arg;
    for (int i = 0; i < ITERATIONS; i++) {
        counter_unsafe++;  /* 保護なし: 競合状態が発生する */
    }
    return NULL;
}
 
void* safe_worker(void* arg) {
    (void)arg;
    for (int i = 0; i < ITERATIONS; i++) {
        /*
         * pthread_mutex_lock: ロックを取得。既に他スレッドがロック中なら待機。
         * 内部ではfutex (Fast Userspace muTEX) syscallを使用:
         *   1. まずアトミック操作でロック取得を試みる（高速パス）
         *   2. 失敗した場合のみカーネルに待機を依頼（低速パス）
         * この2段階設計により、競合がない場合はsyscallを回避できる。
         */
        pthread_mutex_lock(&mtx);
        counter_safe++;
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}
 
int main(void) {
    pthread_t threads[NUM_THREADS];
 
    /* 保護なしの場合 */
    printf("--- 保護なし ---\n");
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, unsafe_worker, NULL);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    printf("期待値: %d, 結果: %ld (競合により減少する可能性が高い)\n",
           NUM_THREADS * ITERATIONS, counter_unsafe);
 
    /* Mutex保護ありの場合 */
    printf("\n--- Mutex保護あり ---\n");
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, safe_worker, NULL);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    printf("期待値: %d, 結果: %ld (常に一致する)\n",
           NUM_THREADS * ITERATIONS, counter_safe);
 
    return 0;
}

"""producer_consumer.py - 条件変数を使った生産者-消費者パターン
 
このパターンは以下のような場面で使われる:
  - Webサーバのリクエストキュー
  - ログ書き込みバッファ
  - 動画エンコードのフレームバッファ
 
実行: python3 producer_consumer.py
"""
import threading
import time
import random
from collections import deque
 
BUFFER_SIZE = 5  # バッファの最大サイズ
 
buffer = deque()
lock = threading.Lock()
not_empty = threading.Condition(lock)  # バッファが空でないことを通知
not_full  = threading.Condition(lock)  # バッファが満杯でないことを通知
 
produced_count = 0
consumed_count = 0
 
def producer(producer_id: int, num_items: int) -> None:
    """アイテムを生産してバッファに追加する。
 
    バッファが満杯の場合は not_full 条件変数で待機する。
    なぜ while ループで条件を確認するか（if ではなく）:
      Spurious Wakeup（偽の起床）の可能性があるため。
      OSの実装上、signal/broadcast なしに条件変数から起床することがある。
      while ループにより、起床後に再度条件を確認することで安全性を保つ。
    """
    global produced_count
    for i in range(num_items):
        item = f"P{producer_id}-Item{i}"
        with not_full:
            while len(buffer) >= BUFFER_SIZE:
                print(f"  Producer {producer_id}: バッファ満杯、待機中...")
                not_full.wait()  # ロック解放 + 待機（アトミックに実行）
 
            buffer.append(item)
            produced_count += 1
            print(f"  Producer {producer_id}: 生産 '{item}' "
                  f"(バッファサイズ: {len(buffer)})")
            not_empty.notify()  # 消費者を1つ起床
 
        time.sleep(random.uniform(0.01, 0.05))  # 生産時間をシミュレート
 
 
def consumer(consumer_id: int, num_items: int) -> None:
    """バッファからアイテムを取り出して消費する。
 
    バッファが空の場合は not_empty 条件変数で待機する。
    """
    global consumed_count
    for _ in range(num_items):
        with not_empty:
            while len(buffer) == 0:
                print(f"  Consumer {consumer_id}: バッファ空、待機中...")
                not_empty.wait()
 
            item = buffer.popleft()
            consumed_count += 1
            print(f"  Consumer {consumer_id}: 消費 '{item}' "
                  f"(バッファサイズ: {len(buffer)})")
            not_full.notify()  # 生産者を1つ起床
 
        time.sleep(random.uniform(0.02, 0.08))  # 消費時間をシミュレート
 
 
def main() -> None:
    NUM_ITEMS_PER_PRODUCER = 5
    NUM_ITEMS_PER_CONSUMER = 5
 
    producers = [
        threading.Thread(target=producer, args=(i, NUM_ITEMS_PER_PRODUCER))
        for i in range(2)
    ]
    consumers = [
        threading.Thread(target=consumer, args=(i, NUM_ITEMS_PER_CONSUMER))
        for i in range(2)
    ]
 
    print("=== 生産者-消費者パターン開始 ===")
    print(f"バッファサイズ上限: {BUFFER_SIZE}")
    print(f"生産者: 2, 消費者: 2\n")
 
    for t in producers + consumers:
        t.start()
    for t in producers + consumers:
        t.join()
 
    print(f"\n=== 完了 ===")
    print(f"生産数: {produced_count}, 消費数: {consumed_count}")
 
 
if __name__ == "__main__":
    main()

/* deadlock_demo.c - デッドロックの発生と回避を示す
 *
 * コンパイル: gcc -Wall -pthread -o deadlock_demo deadlock_demo.c
 * 実行:       ./deadlock_demo
 *
 * このプログラムは2つのシナリオを示す:
 *   1. デッドロックが発生するコード（ロック順序が不統一）
 *   2. デッドロックを回避するコード（ロック順序を統一）
 */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
 
/* 2つの共有リソースに対応するMutex */
static pthread_mutex_t lock_account_a = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t lock_account_b = PTHREAD_MUTEX_INITIALIZER;
 
static int balance_a = 1000;
static int balance_b = 1000;
 
/* ===== デッドロックが発生するバージョン ===== */
 
void* transfer_a_to_b_UNSAFE(void* arg) {
    (void)arg;
    printf("[UNSAFE] Thread 1: lock_account_a を取得\n");
    pthread_mutex_lock(&lock_account_a);
 
    /* sleep で割り込みタイミングを作る。
     * 本番コードでは sleep がなくてもスケジューラの都合で
     * 同じインターリーブが発生しうる。 */
    usleep(100000);  /* 0.1秒 */
 
    printf("[UNSAFE] Thread 1: lock_account_b を待機...\n");
    pthread_mutex_lock(&lock_account_b);
 
    balance_a -= 100;
    balance_b += 100;
    printf("[UNSAFE] Thread 1: 送金完了 A=%d, B=%d\n", balance_a, balance_b);
 
    pthread_mutex_unlock(&lock_account_b);
    pthread_mutex_unlock(&lock_account_a);
    return NULL;
}
 
void* transfer_b_to_a_UNSAFE(void* arg) {
    (void)arg;
    printf("[UNSAFE] Thread 2: lock_account_b を取得\n");
    pthread_mutex_lock(&lock_account_b);  /* ← 順序が逆! */
 
    usleep(100000);
 
    printf("[UNSAFE] Thread 2: lock_account_a を待機...\n");
    pthread_mutex_lock(&lock_account_a);  /* ← デッドロック! */
 
    balance_b -= 200;
    balance_a += 200;
    printf("[UNSAFE] Thread 2: 送金完了 A=%d, B=%d\n", balance_a, balance_b);
 
    pthread_mutex_unlock(&lock_account_a);
    pthread_mutex_unlock(&lock_account_b);
    return NULL;
}
 
/* ===== デッドロックを回避するバージョン ===== */
 
/*
 * 戦略: ロック順序の統一
 * Mutex のアドレスを比較し、常に小さい方を先にロックする。
 * これにより循環待ちが発生し得なくなる。
 *
 * なぜアドレス比較が有効か:
 *   全てのMutexに一意の全順序を定義できるため。
 *   全スレッドがこの順序に従えば、循環待ちのサイクルは形成されない。
 */
void transfer_safe(pthread_mutex_t* from_lock, int* from_balance,
                   pthread_mutex_t* to_lock, int* to_balance,
                   int amount, const char* label) {
    /* アドレスの小さい方を先にロック */
    pthread_mutex_t* first  = (from_lock < to_lock) ? from_lock : to_lock;
    pthread_mutex_t* second = (from_lock < to_lock) ? to_lock : from_lock;
 
    printf("[SAFE] %s: first lock を取得\n", label);
    pthread_mutex_lock(first);
    usleep(100000);
    printf("[SAFE] %s: second lock を取得\n", label);
    pthread_mutex_lock(second);
 
    *from_balance -= amount;
    *to_balance   += amount;
    printf("[SAFE] %s: 送金完了 A=%d, B=%d\n",
           label, balance_a, balance_b);
 
    pthread_mutex_unlock(second);
    pthread_mutex_unlock(first);
}
 
void* safe_a_to_b(void* arg) {
    (void)arg;
    transfer_safe(&lock_account_a, &balance_a,
                  &lock_account_b, &balance_b, 100, "Thread 1");
    return NULL;
}
 
void* safe_b_to_a(void* arg) {
    (void)arg;
    transfer_safe(&lock_account_b, &balance_b,
                  &lock_account_a, &balance_a, 200, "Thread 2");
    return NULL;
}
 
/* ===== タイムアウト付きロックによる回避 ===== */
 
void* transfer_with_timeout(void* arg) {
    (void)arg;
    int retries = 0;
    const int MAX_RETRIES = 5;
 
    while (retries < MAX_RETRIES) {
        pthread_mutex_lock(&lock_account_b);
        usleep(100000);
 
        /*
         * pthread_mutex_trylock: ロック取得を試み、失敗したら即座にEBUSYを返す。
         * ブロックしないため、デッドロックを回避できる。
         * ただし、持っているロックを全て解放してリトライする必要がある。
         */
        int ret = pthread_mutex_trylock(&lock_account_a);
        if (ret == 0) {
            /* ロック取得成功 */
            balance_b -= 200;
            balance_a += 200;
            printf("[TIMEOUT] 送金成功 (リトライ %d回) A=%d, B=%d\n",
                   retries, balance_a, balance_b);
            pthread_mutex_unlock(&lock_account_a);
            pthread_mutex_unlock(&lock_account_b);
            return NULL;
        }
 
        /* ロック取得失敗: 保持中のロックを解放してバックオフ */
        pthread_mutex_unlock(&lock_account_b);
        retries++;
        printf("[TIMEOUT] ロック取得失敗、リトライ #%d\n", retries);
        usleep(rand() % 100000);  /* ランダムバックオフ */
    }
 
    printf("[TIMEOUT] 最大リトライ回数に到達、送金失敗\n");
    return NULL;
}
 
int main(void) {
    srand((unsigned)time(NULL));
 
    /* --- 安全なバージョンを実行 --- */
    printf("=== ロック順序統一による安全な送金 ===\n");
    balance_a = 1000;
    balance_b = 1000;
    pthread_t t1, t2;
    pthread_create(&t1, NULL, safe_a_to_b, NULL);
    pthread_create(&t2, NULL, safe_b_to_a, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("最終残高: A=%d, B=%d (合計=%d、常に2000)\n\n",
           balance_a, balance_b, balance_a + balance_b);
 
    /*
     * 注意: UNSAFE バージョンは意図的にデッドロックするため、
     * コメントアウトしている。試す場合は kill コマンドで強制終了する必要がある。
     *
     * printf("=== デッドロックする送金（注意: ハングする可能性あり） ===\n");
     * balance_a = 1000; balance_b = 1000;
     * pthread_create(&t1, NULL, transfer_a_to_b_UNSAFE, NULL);
     * pthread_create(&t2, NULL, transfer_b_to_a_UNSAFE, NULL);
     * pthread_join(t1, NULL);
     * pthread_join(t2, NULL);
     */
 
    return 0;
}

"""thread_pool.py - スレッドプールの基本実装
 
動作環境: Python 3.8+
実行: python3 thread_pool.py
 
この実装では以下を学ぶ:
  - 条件変数を使ったタスクキューの実装
  - ワーカースレッドのライフサイクル管理
  - グレースフルシャットダウンの方法
"""
import threading
import time
import random
from collections import deque
from typing import Callable, Any, Optional
 
 
class ThreadPool:
    """固定サイズのスレッドプール実装。
 
    なぜ固定サイズか:
      動的にスレッド数を変更する実装は複雑になる。
      固定サイズでもサイジングを適切に行えば十分な性能が得られる。
      Java の ThreadPoolExecutor は動的サイズをサポートするが、
      core/max/keepAlive の設定が複雑になりバグの温床になりやすい。
    """
 
    def __init__(self, num_workers: int) -> None:
        if num_workers <= 0:
            raise ValueError("ワーカー数は1以上でなければならない")
 
        self._num_workers = num_workers
        self._task_queue: deque = deque()
        self._lock = threading.Lock()
        self._not_empty = threading.Condition(self._lock)
        self._running = True
        self._workers: list[threading.Thread] = []
 
        # ワーカースレッドを生成・開始
        for i in range(num_workers):
            t = threading.Thread(
                target=self._worker_loop,
                args=(i,),
                name=f"PoolWorker-{i}",
                daemon=True,  # メインスレッド終了時に自動終了
            )
            t.start()
            self._workers.append(t)
 
        print(f"ThreadPool: {num_workers}個のワーカースレッドを開始")
 
    def _worker_loop(self, worker_id: int) -> None:
        """ワーカースレッドのメインループ。
 
        タスクが到着するまで条件変数で待機し、
        到着したら取り出して実行する。
        """
        while True:
            with self._not_empty:
                # タスクが来るか、シャットダウン指示が出るまで待機
                while len(self._task_queue) == 0 and self._running:
                    self._not_empty.wait()
 
                # シャットダウン指示かつキューが空なら終了
                if not self._running and len(self._task_queue) == 0:
                    print(f"  Worker {worker_id}: シャットダウン")
                    return
 
                func, args, kwargs = self._task_queue.popleft()
 
            # ロック外でタスクを実行（長時間のタスクでもキューをブロックしない）
            try:
                func(*args, **kwargs)
            except Exception as e:
                print(f"  Worker {worker_id}: タスク実行中にエラー: {e}")
 
    def submit(self, func: Callable, *args: Any, **kwargs: Any) -> None:
        """タスクをキューに追加する。"""
        with self._not_empty:
            if not self._running:
                raise RuntimeError("シャットダウン済みのプールにタスクを追加できない")
            self._task_queue.append((func, args, kwargs))
            self._not_empty.notify()  # 待機中のワーカーを1つ起床
 
    def shutdown(self, wait: bool = True) -> None:
        """プールをシャットダウンする。
 
        wait=True の場合、キュー内の全タスクの完了を待つ。
        なぜグレースフルシャットダウンが重要か:
          - 実行中のタスクが途中で中断されるとデータ不整合の原因になる
          - キュー内の未処理タスクが失われる
        """
        print("ThreadPool: シャットダウン開始")
        with self._not_empty:
            self._running = False
            self._not_empty.notify_all()  # 全ワーカーを起床して終了させる
 
        if wait:
            for t in self._workers:
                t.join()
        print("ThreadPool: シャットダウン完了")
 
 
# === デモ用のタスク関数 ===
 
def simulate_io_task(task_id: int) -> None:
    """I/O密度の高いタスクをシミュレート"""
    worker_name = threading.current_thread().name
    print(f"  [{worker_name}] タスク {task_id}: 開始（I/Oシミュレート）")
    time.sleep(random.uniform(0.1, 0.5))  # I/O待ちを模擬
    print(f"  [{worker_name}] タスク {task_id}: 完了")
 
 
def simulate_cpu_task(task_id: int) -> None:
    """CPU密度の高いタスクをシミュレート"""
    worker_name = threading.current_thread().name
    print(f"  [{worker_name}] タスク {task_id}: 開始（CPU計算）")
    total = sum(i * i for i in range(100_000))  # CPU計算
    print(f"  [{worker_name}] タスク {task_id}: 完了 (result={total})")
 
 
if __name__ == "__main__":
    pool = ThreadPool(num_workers=3)
 
    print("\n--- I/Oタスクを投入 ---")
    for i in range(8):
        pool.submit(simulate_io_task, i)
 
    time.sleep(3)  # タスクの完了を待つ
 
    print("\n--- CPUタスクを投入 ---")
    for i in range(4):
        pool.submit(simulate_cpu_task, i)
 
    time.sleep(2)
 
    pool.shutdown(wait=True)

/* ExecutorServiceDemo.java - Java標準のスレッドプール
 *
 * コンパイル・実行: javac ExecutorServiceDemo.java && java ExecutorServiceDemo
 *
 * Java の java.util.concurrent パッケージは産業品質のスレッドプールを提供する。
 * Doug Lea による設計で、高度に最適化されている。
 */
 
import java.util.concurrent.*;
import java.util.ArrayList;
import java.util.List;
 
public class ExecutorServiceDemo {
 
    public static void main(String[] args) throws Exception {
        System.out.println("=== FixedThreadPool ===");
        fixedPoolDemo();
 
        System.out.println("\n=== Future によるタスク結果の取得 ===");
        futureDemo();
 
        System.out.println("\n=== CachedThreadPool vs FixedThreadPool ===");
        comparisonDemo();
    }
 
    static void fixedPoolDemo() throws InterruptedException {
        /*
         * newFixedThreadPool(4): 4つのワーカースレッドを持つプール。
         * タスクが4つ以上投入されると、キューに入り順番を待つ。
         *
         * なぜ固定サイズが推奨されるか:
         *   CachedThreadPool は無制限にスレッドを生成するため、
         *   大量のタスクが一度に投入されるとOOM(OutOfMemory)の危険がある。
         *   FixedThreadPool はスレッド数の上限が保証される。
         */
        ExecutorService pool = Executors.newFixedThreadPool(4);
 
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            pool.execute(() -> {
                String name = Thread.currentThread().getName();
                System.out.printf("  [%s] Task %d: 開始%n", name, taskId);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.printf("  [%s] Task %d: 完了%n", name, taskId);
            });
        }
 
        pool.shutdown();
        /*
         * shutdown(): 新規タスクの受付を停止し、既存タスクの完了を待つ。
         * shutdownNow(): 実行中のタスクに割り込みを送り、即座に停止を試みる。
         *
         * awaitTermination(): 指定時間内に全タスクが完了するまで待機。
         */
        boolean finished = pool.awaitTermination(10, TimeUnit.SECONDS);
        System.out.println("全タスク完了: " + finished);
    }
 
    static void futureDemo() throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        List<Future<Long>> futures = new ArrayList<>();
 
        for (int i = 1; i <= 5; i++) {
            final int n = i * 10_000_000;
            /*
             * submit(Callable): 戻り値を持つタスクを投入。
             * Future オブジェクトを返し、get() で結果を取得できる。
             * get() はタスク完了まで呼び出し元をブロックする。
             */
            Future<Long> future = pool.submit(() -> {
                long sum = 0;
                for (int j = 0; j < n; j++) {
                    sum += j;
                }
                return sum;
            });
            futures.add(future);
        }
 
        for (int i = 0; i < futures.size(); i++) {
            /* get() はブロッキング呼び出し。タイムアウト付きの get(timeout, unit) も利用可能。 */
            long result = futures.get(i).get();
            System.out.printf("  Task %d 結果: %,d%n", i, result);
        }
 
        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.SECONDS);
    }
 
    static void comparisonDemo() {
        /*
         * CachedThreadPool:
         *   - スレッド数の上限なし（Integer.MAX_VALUE）
         *   - 60秒間アイドルのスレッドは自動破棄
         *   - 短命で大量のタスクに向くが、暴走の危険あり
         *
         * FixedThreadPool:
         *   - スレッド数が固定
         *   - タスクキューは無制限（LinkedBlockingQueue）
         *   - 安定した負荷に向く
         *
         * WorkStealingPool (Java 8+):
         *   - ForkJoinPool ベース
         *   - 各ワーカーが独自のキューを持ち、他ワーカーからタスクを盗む
         *   - 不均一なタスクサイズに向く
         */
        System.out.println("  CachedThreadPool:     上限なし、短命タスク向き");
        System.out.println("  FixedThreadPool:      固定サイズ、安定負荷向き");
        System.out.println("  WorkStealingPool:     Work Stealing、不均一タスク向き");
        System.out.println("  ScheduledThreadPool:  定期実行タスク向き");
        System.out.println("  VirtualThreadPerTask: Java 21+ 仮想スレッド版");
    }
}

"""antipattern_giant_lock.py - ロック粒度が大きすぎるアンチパターン
 
問題:
  単一のロックで全てのデータを保護すると、並行性が失われる。
  あるスレッドが accounts['A'] を操作中に、
  無関係な accounts['B'] へのアクセスもブロックされてしまう。
"""
import threading
import time
 
# === アンチパターン: 単一のグローバルロック ===
 
class BankAccountGiantLock:
    """全アカウントを1つのロックで保護する（並行性が低い）。
 
    なぜこれが問題か:
      100個のアカウントがあっても、同時に1つのスレッドしか
      どのアカウントにもアクセスできない。
      これは事実上シングルスレッド実行と同じである。
    """
    def __init__(self):
        self.accounts = {'A': 1000, 'B': 1000, 'C': 1000}
        self.lock = threading.Lock()  # 1つのロックで全アカウントを保護
 
    def transfer(self, from_acc, to_acc, amount):
        with self.lock:  # 全アカウントがブロックされる
            time.sleep(0.01)  # I/Oをシミュレート
            self.accounts[from_acc] -= amount
            self.accounts[to_acc] += amount
 
 
# === 改善: 細粒度ロック（アカウントごとにロック） ===
 
class BankAccountFineLock:
    """アカウントごとに個別のロックを持つ（並行性が高い）。
 
    改善のポイント:
      accounts['A'] と accounts['C'] への操作は
      同時に進行できるようになる。
      ただし、デッドロック防止のためロック順序の統一が必要。
    """
    def __init__(self):
        self.accounts = {'A': 1000, 'B': 1000, 'C': 1000}
        self.locks = {k: threading.Lock() for k in self.accounts}
 
    def transfer(self, from_acc, to_acc, amount):
        # アカウント名の辞書順でロックを取得（デッドロック防止）
        first, second = sorted([from_acc, to_acc])
        with self.locks[first]:
            with self.locks[second]:
                time.sleep(0.01)
                self.accounts[from_acc] -= amount
                self.accounts[to_acc] += amount
 
 
def benchmark(bank, label):
    start = time.time()
    threads = []
    # A→B と C→A の送金を並行に実行
    for _ in range(10):
        t1 = threading.Thread(target=bank.transfer, args=('A', 'B', 10))
        t2 = threading.Thread(target=bank.transfer, args=('C', 'A', 10))
        threads.extend([t1, t2])
 
    for t in threads:
        t.start()
    for t in threads:
        t.join()
 
    elapsed = time.time() - start
    total = sum(bank.accounts.values())
    print(f"  {label}: {elapsed:.3f}秒, 合計残高={total} (常に3000)")
 
 
if __name__ == "__main__":
    print("=== ロック粒度の比較 ===")
    benchmark(BankAccountGiantLock(), "Giant Lock  ")
    benchmark(BankAccountFineLock(),  "Fine Lock   ")
    print("\n  Fine Lock の方が高速になる（並行実行が可能なため）")

"""antipattern_spurious_wakeup.py - 条件変数の誤った使い方
 
問題:
  条件変数の wait() から戻った時、条件が成立しているとは限らない。
  OS の実装上、signal/broadcast なしに起床する「偽の起床」が発生しうる。
  if で条件をチェックすると、偽の起床時に不正な状態で処理が進む。
"""
import threading
from collections import deque
 
buffer = deque()
lock = threading.Lock()
cond = threading.Condition(lock)
 
# === アンチパターン: if で条件チェック ===
 
def consumer_BAD():
    """偽の起床を考慮していない危険なコード。
 
    なぜ危険か:
      wait() から戻った直後に buffer が空の可能性がある。
      1. 偽の起床（Spurious Wakeup）: OSが予期せずスレッドを起床させる
      2. broadcast 後の競合: 他のconsumerが先にアイテムを取ってしまう
 
      結果: buffer が空の状態で popleft() を呼び、IndexError が発生する。
    """
    with cond:
        if len(buffer) == 0:  # if は1回しかチェックしない
            cond.wait()
        # ここに到達しても buffer が空の可能性がある!
        item = buffer.popleft()  # IndexError の可能性
 
 
# === 正しいパターン: while で条件チェック ===
 
def consumer_GOOD():
    """while ループで条件を再確認する安全なコード。
 
    なぜ while が正しいか:
      wait() から戻るたびに条件を再チェックする。
      偽の起床や broadcast 後の競合があっても、
      条件が成立するまでループが待機を続ける。
    """
    with cond:
        while len(buffer) == 0:  # while で毎回チェック
            cond.wait()
        # ここに到達した時点で必ず buffer にアイテムがある
        item = buffer.popleft()  # 安全
        return item

/* DoubleCheckedLocking.java - スレッドセーフな遅延初期化
 *
 * コンパイル・実行: javac DoubleCheckedLocking.java && java DoubleCheckedLocking
 */
 
public class DoubleCheckedLocking {
 
    /*
     * なぜ volatile が必要か:
     *
     * Java のメモリモデルでは、コンパイラやCPUが命令の順序を
     * 最適化（リオーダー）する場合がある。
     * volatile なしの場合、以下のような問題が発生しうる:
     *
     *   1. メモリ確保
     *   2. instance にアドレスを代入  ← リオーダーでここが先になる
     *   3. コンストラクタ実行        ← まだ初期化されていない
     *
     *   別のスレッドがステップ2の後、ステップ3の前に instance をチェックすると、
     *   null でないが未初期化のオブジェクトを受け取る。
     *
     * volatile は happens-before 関係を保証し、
     * リオーダーを防止する。
     */
    private static volatile DoubleCheckedLocking instance;
 
    private final String data;
 
    private DoubleCheckedLocking() {
        // 重い初期化処理をシミュレート
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        this.data = "初期化完了 @ " + System.currentTimeMillis();
    }
 
    public static DoubleCheckedLocking getInstance() {
        /*
         * Double-Checked Locking パターン:
         *
         * 1回目のチェック（ロックなし）: 高速パス
         *   既に初期化済みの場合、ロック取得のオーバーヘッドを回避
         *
         * 2回目のチェック（ロック内）: 安全なチェック
         *   1回目のチェックと lock の間に他スレッドが初期化した場合を検出
         */
        if (instance == null) {              // 1回目のチェック（高速パス）
            synchronized (DoubleCheckedLocking.class) {
                if (instance == null) {      // 2回目のチェック（安全な確認）
                    instance = new DoubleCheckedLocking();
                }
            }
        }
        return instance;
    }
 
    public String getData() {
        return data;
    }
 
    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            final int id = i;
            threads[i] = new Thread(() -> {
                DoubleCheckedLocking obj = DoubleCheckedLocking.getInstance();
                System.out.printf("Thread %d: %s (hash=%d)%n",
                    id, obj.getData(), System.identityHashCode(obj));
            });
        }
 
        for (Thread t : threads) t.start();
        for (Thread t : threads) t.join();
 
        System.out.println("\n全スレッドが同じインスタンスを取得していることを確認");
        System.out.println("(全ての hash 値が同一であるべき)");
    }
}

/* thread_local_demo.c - スレッドローカルストレージの使用例
 *
 * コンパイル: gcc -Wall -pthread -o tls_demo thread_local_demo.c
 * 実行:       ./tls_demo
 */
#include <stdio.h>
#include <pthread.h>
 
/*
 * _Thread_local (C11) / __thread (GCC拡張) でスレッドローカル変数を宣言。
 * 各スレッドがこの変数の独立したコピーを持つ。
 *
 * 内部実装:
 *   ELF バイナリの .tdata / .tbss セクションに格納される。
 *   各スレッドの TCB に TLS ブロックへのポインタがあり、
 *   fs/gs セグメントレジスタを介してアクセスする。
 */
static _Thread_local int tls_counter = 0;
static int shared_counter = 0;  /* 比較用: 共有変数 */
 
void* worker(void* arg) {
    int id = *(int*)arg;
 
    for (int i = 0; i < 1000; i++) {
        tls_counter++;      /* スレッドローカル: 競合なし */
        shared_counter++;   /* 共有変数: 競合状態が発生 */
    }
 
    printf("Thread %d: tls_counter=%d (常に1000), "
           "shared_counter=%d (競合により不定)\n",
           id, tls_counter, shared_counter);
    return NULL;
}
 
int main(void) {
    const int N = 4;
    pthread_t threads[N];
    int ids[N];
 
    for (int i = 0; i < N; i++) {
        ids[i] = i;
        pthread_create(&threads[i], NULL, worker, &ids[i]);
    }
    for (int i = 0; i < N; i++) {
        pthread_join(threads[i], NULL);
    }
 
    printf("\n最終 shared_counter = %d (期待値4000、競合により減少する可能性)\n",
           shared_counter);
    return 0;
}

"""exercise_01_race_condition.py - 競合状態の観測
 
課題:
  1. 以下のコードを lock なしで実行し、counter の値が期待値より小さくなることを確認せよ
  2. lock を有効にして実行し、counter が常に期待値と一致することを確認せよ
  3. ITERATIONS の値を変えて、競合の発生頻度がどう変わるか観察せよ
     (小さい値では競合が観測しにくく、大きい値では顕著になる理由を考えよ)
 
ヒント:
  小さい ITERATIONS で競合が観測しにくいのは、
  スレッドの実行時間が短すぎて、オーバーラップする確率が低いためである。
 
実行: python3 exercise_01_race_condition.py
"""
import threading
import time
 
ITERATIONS = 1_000_000
NUM_THREADS = 4
 
counter = 0
lock = threading.Lock()
USE_LOCK = False  # True に変更して比較せよ
 
def worker():
    global counter
    for _ in range(ITERATIONS):
        if USE_LOCK:
            with lock:
                counter += 1
        else:
            counter += 1
 
def main():
    global counter
    expected = ITERATIONS * NUM_THREADS
 
    # 10回繰り返して統計を取る
    results = []
    for trial in range(10):
        counter = 0
        threads = [threading.Thread(target=worker) for _ in range(NUM_THREADS)]
        start = time.time()
        for t in threads:
            t.start()
        for t in threads:
            t.join()
        elapsed = time.time() - start
        results.append(counter)
        print(f"  Trial {trial+1:2d}: counter={counter:>10,} "
              f"(期待値: {expected:>10,}) "
              f"差: {expected - counter:>8,}  "
              f"時間: {elapsed:.3f}秒")
 
    print(f"\n  最小値: {min(results):,}")
    print(f"  最大値: {max(results):,}")
    print(f"  期待値: {expected:,}")
    print(f"  USE_LOCK: {USE_LOCK}")
 
if __name__ == "__main__":
    main()

"""exercise_02_deadlock.py - デッドロック回避の3手法
 
課題:
  1. deadlock_scenario() を実行し、プログラムがハングすることを確認せよ
     (Ctrl+C で中断)
  2. 以下の3つの回避手法をそれぞれ実装せよ:
     a) ロック順序の統一（lock_ordering）
     b) タイムアウト付きロック（timeout_approach）
     c) contextmanager による一括ロック取得（batch_locking）
  3. 各手法の長所と短所を整理せよ
 
実行: python3 exercise_02_deadlock.py
"""
import threading
import time
import contextlib
 
lock_x = threading.Lock()
lock_y = threading.Lock()
 
# === デッドロックが発生するコード ===
 
def deadlock_worker_1():
    lock_x.acquire()
    print("Worker 1: lock_x 取得")
    time.sleep(0.1)  # 他スレッドが lock_y を取る隙を作る
    print("Worker 1: lock_y を待機...")
    lock_y.acquire()  # デッドロック!
    print("Worker 1: 両方取得")
    lock_y.release()
    lock_x.release()
 
def deadlock_worker_2():
    lock_y.acquire()
    print("Worker 2: lock_y 取得")
    time.sleep(0.1)
    print("Worker 2: lock_x を待機...")
    lock_x.acquire()  # デッドロック!
    print("Worker 2: 両方取得")
    lock_x.release()
    lock_y.release()
 
def deadlock_scenario():
    """このまま実行するとデッドロックでハングする"""
    t1 = threading.Thread(target=deadlock_worker_1)
    t2 = threading.Thread(target=deadlock_worker_2)
    t1.start()
    t2.start()
    t1.join(timeout=3)
    t2.join(timeout=3)
    if t1.is_alive() or t2.is_alive():
        print(">>> デッドロック検出! (3秒でタイムアウト)")
 
# === 回避手法 a) ロック順序の統一 ===
# TODO: id() を使ってロックのアドレスで順序を決定し、
#       常に小さい方を先にロックする実装を書け
 
# === 回避手法 b) タイムアウト付きロック ===
# TODO: lock.acquire(timeout=...) を使い、
#       タイムアウト時に全ロックを解放してリトライする実装を書け
 
# === 回避手法 c) 一括ロック取得 ===
# TODO: 必要な全ロックをソートして一括取得する
#       contextmanager を実装せよ
 
if __name__ == "__main__":
    print("=== デッドロック再現 ===")
    deadlock_scenario()

"""exercise_03_advanced_pool.py - スレッドプールの拡張
 
課題:
  以下の機能を ThreadPool クラスに追加せよ:
 
  1. submit_with_future(): タスクの結果を Future オブジェクトで返す
     - result = pool.submit_with_future(func, args)
     - value = result.get(timeout=5.0)  # ブロッキングで結果を取得
 
  2. map(): 複数の引数に同じ関数を並列適用
     - results = pool.map(func, [arg1, arg2, arg3])
     - list(results) で全結果を取得
 
  3. 統計情報の収集:
     - pool.stats() で以下を返す:
       - 完了タスク数
       - キュー内の待機タスク数
       - アクティブワーカー数
       - 平均タスク実行時間
 
  ヒント:
  - Future は内部で threading.Event を使い、
    set() で結果の到着を通知、wait() で結果を待機する
  - map() は submit_with_future() を内部で使い、
    全ての Future を収集して結果を返すジェネレータとして実装できる
 
実行: python3 exercise_03_advanced_pool.py
"""
import threading
import time
from collections import deque
from typing import Callable, Any, Iterator
 
class Future:
    """タスクの非同期結果を表すオブジェクト。
 
    TODO: 以下を実装せよ
    - __init__: Event と result/exception の初期化
    - set_result(value): 結果をセットして Event を通知
    - set_exception(exc): 例外をセットして Event を通知
    - get(timeout=None): 結果が到着するまで待機し、返す
    """
    pass
 
class AdvancedThreadPool:
    """拡張版スレッドプール。
 
    TODO: section 5.3 の ThreadPool をベースに、
    上記3つの機能を追加せよ
    """
    pass
 
if __name__ == "__main__":
    print("=== 演習3: 拡張スレッドプール ===")
    print("上記の TODO を実装して動作を確認せよ")
    print()
    print("テスト項目:")
    print("  1. submit_with_future で計算結果を取得")
    print("  2. map で複数引数を並列処理")
    print("  3. stats で統計情報を確認")
    print("  4. グレースフルシャットダウンの動作確認")