/* process_info.c
 * コンパイル: gcc -Wall -o process_info process_info.c
 * 実行: ./process_info
 *
 * 目的: プロセスの基本的な属性（PID、PPID、UID等）を取得し、
 *       プロセスが持つ情報の一部を確認する。
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/resource.h>
#include <limits.h>
 
int global_initialized = 42;  /* Dataセグメントに配置される */
int global_uninitialized;     /* BSSセグメントに配置される */
 
int main(void)
{
    int stack_variable = 100;               /* スタックに配置 */
    int *heap_variable = malloc(sizeof(int)); /* ヒープに配置 */
    if (heap_variable == NULL) {
        perror("malloc");
        return 1;
    }
    *heap_variable = 200;
 
    printf("=== プロセス基本情報 ===\n");
    printf("PID  (プロセスID):   %d\n", getpid());
    printf("PPID (親プロセスID): %d\n", getppid());
    printf("UID  (ユーザーID):   %d\n", getuid());
    printf("GID  (グループID):   %d\n", getgid());
    printf("SID  (セッションID): %d\n", getsid(0));
 
    printf("\n=== メモリアドレスの確認 ===\n");
    printf("テキスト (main関数):      %p\n", (void *)main);
    printf("データ (初期化済み):      %p\n", (void *)&global_initialized);
    printf("BSS  (未初期化):          %p\n", (void *)&global_uninitialized);
    printf("ヒープ (malloc):          %p\n", (void *)heap_variable);
    printf("スタック (ローカル変数):   %p\n", (void *)&stack_variable);
 
    /* アドレスの大小関係を検証:
     * テキスト < データ < BSS < ヒープ < ... < スタック
     * が典型的な配置であることを確認する */
    printf("\n=== アドレス順序の検証 ===\n");
    if ((void *)main < (void *)&global_initialized)
        printf("テキスト < データ: 正常な配置\n");
    if ((void *)&global_uninitialized < (void *)heap_variable)
        printf("BSS < ヒープ: 正常な配置\n");
    if ((void *)heap_variable < (void *)&stack_variable)
        printf("ヒープ < スタック: 正常な配置\n");
 
    /* リソース制限の確認 */
    struct rlimit rl;
    if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
        printf("\n=== リソース制限 ===\n");
        printf("開けるファイル数: soft=%lu, hard=%lu\n",
               (unsigned long)rl.rlim_cur, (unsigned long)rl.rlim_max);
    }
    if (getrlimit(RLIMIT_STACK, &rl) == 0) {
        printf("スタックサイズ:   soft=%lu bytes (%lu MB)\n",
               (unsigned long)rl.rlim_cur,
               (unsigned long)rl.rlim_cur / (1024 * 1024));
    }
 
    free(heap_variable);
    return 0;
}

#!/usr/bin/env python3
"""process_states.py
プロセスの状態遷移を観察するデモプログラム。
Linux環境で実行すること（/procファイルシステムを使用するため）。
 
実行方法: python3 process_states.py
"""
import os
import sys
import time
import signal
 
def get_process_state(pid):
    """指定PIDのプロセス状態を/procから取得する。
 
    /proc/[pid]/statusファイルにはプロセスの状態が記録されている。
    State行の値は以下の通り:
      R: Running (実行中/実行可能)
      S: Sleeping (割り込み可能なスリープ = Blocked)
      D: Disk sleep (割り込み不可のスリープ)
      T: Stopped (停止)
      Z: Zombie (ゾンビ)
    """
    try:
        with open(f"/proc/{pid}/status", "r") as f:
            for line in f:
                if line.startswith("State:"):
                    return line.strip()
    except FileNotFoundError:
        return "プロセスが存在しない（終了済み）"
    except PermissionError:
        return "権限不足で読み取れない"
    return "状態不明"
 
def main():
    print(f"親プロセス PID: {os.getpid()}")
    print(f"親の状態: {get_process_state(os.getpid())}")
    print()
 
    # 子プロセスを生成
    pid = os.fork()
 
    if pid == 0:
        # --- 子プロセス ---
        print(f"[子] PID={os.getpid()} が生成された (Ready → Running)")
 
        # I/O操作でBlocked状態に遷移することをデモ
        print(f"[子] I/O操作（sleep）でBlocked状態へ...")
        time.sleep(2)  # sleepはSleeping(S)状態になる
 
        print(f"[子] I/O完了 → Ready → Running")
        print(f"[子] 正常終了 → Terminated")
        sys.exit(0)
    else:
        # --- 親プロセス ---
        time.sleep(0.5)  # 子が確実にsleep状態に入るのを待つ
 
        # 子プロセスの状態を観察
        state = get_process_state(pid)
        print(f"[親] 子プロセス(PID={pid})の状態: {state}")
        print(f"      → sleep中のため S (Sleeping) のはず")
        print()
 
        # 子が終了するのを待つが、すぐにwait()しない
        time.sleep(3)  # 子はすでに終了しているはず
 
        # wait()する前にゾンビ状態を確認
        state = get_process_state(pid)
        print(f"[親] 子プロセスの状態（wait前）: {state}")
        print(f"      → wait()前なので Z (Zombie) の可能性がある")
 
        # wait()でゾンビを回収
        result_pid, status = os.waitpid(pid, 0)
        print(f"\n[親] waitpid完了: 子PID={result_pid}, 終了ステータス={os.WEXITSTATUS(status)}")
 
        # wait()後はプロセスが消滅
        state = get_process_state(pid)
        print(f"[親] 子プロセスの状態（wait後）: {state}")
 
if __name__ == "__main__":
    if sys.platform != "linux":
        print("注意: このプログラムはLinux環境専用です（/procを使用）")
        print("macOSでは /proc が存在しないため、状態取得部分は動作しません")
        print("代わりに ps コマンドでプロセス状態を確認できます")
        print()
    main()

/* fork_exec_demo.c
 * コンパイル: gcc -Wall -o fork_exec_demo fork_exec_demo.c
 * 実行: ./fork_exec_demo
 *
 * 目的: fork/execモデルでコマンドを実行し、
 *       リダイレクションの仕組みを理解する。
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
 
/* 指定されたコマンドを子プロセスで実行する。
 * output_file が非NULLの場合、stdoutをそのファイルにリダイレクトする。
 *
 * なぜfork後exec前にリダイレクト設定をするのか？
 * → exec()は現在のプロセスのプログラムを置換するが、
 *   ファイルディスクリプタテーブルは（FD_CLOEXECが設定されていない限り）
 *   そのまま引き継がれる。そのため、exec前にfd 1（stdout）を
 *   ファイルに付け替えておけば、新しいプログラムの標準出力が
 *   自動的にそのファイルに向く。
 */
int run_command(char *const argv[], const char *output_file)
{
    pid_t pid = fork();
 
    if (pid < 0) {
        /* fork失敗。考えられる原因:
         * - プロセス数上限（RLIMIT_NPROC）に達した
         * - メモリ不足
         * - PID空間の枯渇（極めて稀） */
        perror("fork");
        return -1;
    }
 
    if (pid == 0) {
        /* --- 子プロセス --- */
 
        /* リダイレクションが指定されている場合 */
        if (output_file != NULL) {
            /* 出力ファイルを開く
             * O_WRONLY: 書き込み専用
             * O_CREAT:  存在しなければ作成
             * O_TRUNC:  既存の内容を削除
             * 0644:     rw-r--r-- パーミッション */
            int fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
            if (fd < 0) {
                perror("open");
                _exit(1);  /* 子プロセスでは _exit() を使う。
                            * exit() を使うと、親プロセスで登録された
                            * atexit ハンドラが実行される可能性がある。 */
            }
 
            /* fd 1（stdout）をファイルに付け替え */
            if (dup2(fd, STDOUT_FILENO) < 0) {
                perror("dup2");
                _exit(1);
            }
 
            /* 元のfdはもう不要なので閉じる
             * （fd 1が同じファイルを指しているため） */
            close(fd);
        }
 
        /* プログラムを実行（現在のプロセスの内容が置換される） */
        execvp(argv[0], argv);
 
        /* execvpが返ってきた場合、エラーが発生している */
        fprintf(stderr, "execvp失敗: %s: %s\n", argv[0], strerror(errno));
        _exit(127);  /* コマンドが見つからない場合は127を返す慣習 */
    }
 
    /* --- 親プロセス --- */
    int status;
    if (waitpid(pid, &status, 0) < 0) {
        perror("waitpid");
        return -1;
    }
 
    if (WIFEXITED(status)) {
        int exit_code = WEXITSTATUS(status);
        printf("[親] 子プロセス(PID=%d)が終了コード %d で終了\n",
               pid, exit_code);
        return exit_code;
    } else if (WIFSIGNALED(status)) {
        int sig = WTERMSIG(status);
        printf("[親] 子プロセス(PID=%d)がシグナル %d で終了\n",
               pid, sig);
        return -1;
    }
 
    return -1;
}
 
int main(void)
{
    /* コマンド1: ls -la を実行（標準出力へ） */
    printf("=== ls -la の実行 ===\n");
    char *cmd1[] = {"ls", "-la", "/tmp", NULL};
    run_command(cmd1, NULL);
 
    /* コマンド2: ls -la の出力をファイルにリダイレクト */
    printf("\n=== ls -la > /tmp/ls_output.txt ===\n");
    char *cmd2[] = {"ls", "-la", "/tmp", NULL};
    run_command(cmd2, "/tmp/ls_output.txt");
    printf("出力が /tmp/ls_output.txt に書き込まれた\n");
 
    /* コマンド3: 存在しないコマンドを実行（エラー処理のデモ） */
    printf("\n=== 存在しないコマンドの実行 ===\n");
    char *cmd3[] = {"nonexistent_command", NULL};
    run_command(cmd3, NULL);
 
    return 0;
}

/* zombie_demo.c
 * コンパイル: gcc -Wall -o zombie_demo zombie_demo.c
 * 実行: ./zombie_demo
 *
 * 目的: ゾンビプロセスの発生メカニズムと回収方法を理解する。
 *       実行中に別ターミナルで ps aux | grep zombie で確認すると、
 *       Z状態のプロセスが見える。
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
 
/* === 方法1: 明示的にwait()で回収 === */
void demo_explicit_wait(void)
{
    printf("\n=== 方法1: 明示的なwait() ===\n");
    pid_t pid = fork();
 
    if (pid == 0) {
        /* 子プロセス: すぐに終了 */
        printf("[子] PID=%d 終了します\n", getpid());
        _exit(42);
    }
 
    /* 親プロセス: 5秒間wait()しない → ゾンビが発生 */
    printf("[親] 子(PID=%d)が終了。5秒間wait()しません...\n", pid);
    printf("[親] この間に 'ps aux | grep zombie' で Z 状態を確認してください\n");
    sleep(5);
 
    /* wait()でゾンビを回収 */
    int status;
    waitpid(pid, &status, 0);
    printf("[親] 子を回収。終了コード=%d\n", WEXITSTATUS(status));
}
 
/* === 方法2: SIGCHLDシグナルハンドラで自動回収 === */
volatile sig_atomic_t child_count = 0;
 
void sigchld_handler(int signo)
{
    (void)signo;  /* 未使用パラメータ警告を抑制 */
 
    /* wait()を非ブロッキングで呼び、全ての終了済み子を回収する。
     * なぜwhileループか？ → 複数の子が同時に終了した場合、
     * SIGCHLDは1回しか配送されないことがあるため、
     * ループで全て回収する必要がある。 */
    pid_t pid;
    int status;
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        child_count++;
        /* シグナルハンドラ内ではasync-signal-safe関数のみ使用可能。
         * printf()はasync-signal-safeでないが、デモのため使用。
         * 本番コードではwrite()を使うべき。 */
    }
}
 
void demo_sigchld_handler(void)
{
    printf("\n=== 方法2: SIGCHLDハンドラによる自動回収 ===\n");
 
    /* SIGCHLDハンドラを設定 */
    struct sigaction sa;
    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;  /* システムコールの自動再起動 */
    sigaction(SIGCHLD, &sa, NULL);
 
    /* 5つの子プロセスを生成 */
    for (int i = 0; i < 5; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            printf("[子%d] PID=%d 終了します\n", i, getpid());
            _exit(0);
        }
        printf("[親] 子%d(PID=%d)を生成\n", i, pid);
    }
 
    /* ハンドラが全ての子を回収するのを待つ */
    sleep(2);
    printf("[親] 回収された子プロセス数: %d\n", child_count);
}
 
/* === 方法3: SIGCHLDをSIG_IGNに設定 === */
void demo_sigign(void)
{
    printf("\n=== 方法3: SIGCHLD を SIG_IGN に設定 ===\n");
 
    /* SIGCHLDをSIG_IGNに設定すると、子プロセスは終了時に
     * 自動的に回収され、ゾンビにならない。
     * ただし、wait()で子の終了ステータスを取得できなくなる。
     * この動作はPOSIXで明確に定義されている。 */
    signal(SIGCHLD, SIG_IGN);
 
    pid_t pid = fork();
    if (pid == 0) {
        printf("[子] PID=%d 終了します\n", getpid());
        _exit(0);
    }
 
    sleep(1);
    printf("[親] ゾンビは発生しない（自動回収される）\n");
 
    /* デフォルトに戻す */
    signal(SIGCHLD, SIG_DFL);
}
 
int main(void)
{
    printf("ゾンビプロセスのデモ (親PID=%d)\n", getpid());
 
    demo_explicit_wait();
    demo_sigchld_handler();
    demo_sigign();
 
    printf("\n全てのデモが完了\n");
    return 0;
}

/* pipe_demo.c
 * コンパイル: gcc -Wall -o pipe_demo pipe_demo.c
 * 実行: ./pipe_demo
 *
 * 目的: パイプを使ったプロセス間通信の仕組みを理解する。
 *       ls | grep のようなシェルパイプラインの内部動作を再現する。
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
 
int main(void)
{
    int pipefd[2];
 
    /* pipe() はファイルディスクリプタのペアを作成する。
     * pipefd[0]: 読み取り用（パイプの出口）
     * pipefd[1]: 書き込み用（パイプの入口）
     *
     * なぜ2つのfdが必要か？
     * → パイプは一方向通信。データの流れの方向を明確にするため、
     *   書き込み用と読み取り用を別々のfdで管理する。
     */
    if (pipe(pipefd) < 0) {
        perror("pipe");
        return 1;
    }
 
    printf("パイプ作成: read_fd=%d, write_fd=%d\n", pipefd[0], pipefd[1]);
 
    /* === 第1子プロセス: ls -la /tmp === */
    pid_t pid1 = fork();
    if (pid1 < 0) {
        perror("fork");
        return 1;
    }
 
    if (pid1 == 0) {
        /* 子プロセス1: ls コマンド
         *
         * stdout (fd 1) をパイプの書き込み端に付け替える。
         * lsの出力がパイプに流れ込むようになる。
         */
        close(pipefd[0]);  /* 読み取り端は使わないので閉じる。
                            * 閉じないと、パイプの読み取り端を持つプロセスが
                            * 残り続け、grep側でEOFを検知できなくなる。 */
 
        dup2(pipefd[1], STDOUT_FILENO);  /* fd 1 → パイプ書き込み端 */
        close(pipefd[1]);  /* dup2後は元のfdは不要 */
 
        execlp("ls", "ls", "-la", "/tmp", NULL);
        perror("execlp ls");
        _exit(1);
    }
 
    /* === 第2子プロセス: grep === */
    pid_t pid2 = fork();
    if (pid2 < 0) {
        perror("fork");
        return 1;
    }
 
    if (pid2 == 0) {
        /* 子プロセス2: grep コマンド
         *
         * stdin (fd 0) をパイプの読み取り端に付け替える。
         * パイプから流れてくるデータをgrepの入力にする。
         */
        close(pipefd[1]);  /* 書き込み端は使わないので閉じる */
 
        dup2(pipefd[0], STDIN_FILENO);  /* fd 0 → パイプ読み取り端 */
        close(pipefd[0]);
 
        /* "." を含む行を検索（任意のファイルにマッチ） */
        execlp("grep", "grep", "--color=auto", "\\.", NULL);
        perror("execlp grep");
        _exit(1);
    }
 
    /* === 親プロセス === */
    /* 親プロセスはパイプの両端を閉じる必要がある。
     * 特に書き込み端を閉じないと、パイプに書き込むプロセスが
     * 残り続けることになり、grep側がEOFを受け取れない。 */
    close(pipefd[0]);
    close(pipefd[1]);
 
    /* 両方の子プロセスの終了を待つ */
    int status1, status2;
    waitpid(pid1, &status1, 0);
    waitpid(pid2, &status2, 0);
 
    printf("\n--- パイプライン完了 ---\n");
    printf("ls  終了コード: %d\n", WEXITSTATUS(status1));
    printf("grep 終了コード: %d\n", WEXITSTATUS(status2));
 
    return 0;
}

/* shared_memory_demo.c
 * コンパイル: gcc -Wall -o shared_memory_demo shared_memory_demo.c -lrt -lpthread
 * 実行: ./shared_memory_demo
 *
 * 目的: POSIX共有メモリとセマフォを使った
 *       プロセス間通信の仕組みを理解する。
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <semaphore.h>
 
/* 共有メモリ上に配置するデータ構造 */
typedef struct {
    sem_t sem_producer;  /* 書き手の同期用セマフォ */
    sem_t sem_consumer;  /* 読み手の同期用セマフォ */
    int   data;          /* 共有データ */
    int   done;          /* 終了フラグ */
} shared_data_t;
 
#define SHM_NAME "/process_demo_shm"
 
int main(void)
{
    /* POSIX共有メモリオブジェクトを作成する。
     * shm_open()はファイルディスクリプタを返す。
     * このfdは/dev/shm以下のファイルに対応する（Linuxの場合）。
     *
     * なぜファイルベースのAPIなのか？
     * → "全てはファイル"というUnix哲学に従い、
     *   既存のファイル操作API（ftruncate, mmap等）を
     *   再利用できるようにしている。 */
    int shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    if (shm_fd < 0) {
        perror("shm_open");
        return 1;
    }
 
    /* 共有メモリのサイズを設定 */
    if (ftruncate(shm_fd, sizeof(shared_data_t)) < 0) {
        perror("ftruncate");
        return 1;
    }
 
    /* 共有メモリをプロセスのアドレス空間にマッピング */
    shared_data_t *shm = mmap(NULL, sizeof(shared_data_t),
                              PROT_READ | PROT_WRITE,
                              MAP_SHARED, shm_fd, 0);
    if (shm == MAP_FAILED) {
        perror("mmap");
        return 1;
    }
    close(shm_fd);  /* mmapした後はfdを閉じてよい */
 
    /* プロセス間で共有可能なセマフォを初期化。
     * 第2引数の1はプロセス間共有を意味する（0ならスレッド間のみ）。 */
    sem_init(&shm->sem_producer, 1, 1);  /* 最初は書き手が動ける */
    sem_init(&shm->sem_consumer, 1, 0);  /* 読み手はデータ待ち */
    shm->done = 0;
 
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    }
 
    if (pid == 0) {
        /* --- 子プロセス（消費者/Consumer） --- */
        printf("[Consumer PID=%d] 開始\n", getpid());
 
        while (1) {
            sem_wait(&shm->sem_consumer);  /* データが来るまで待つ */
 
            if (shm->done) {
                printf("[Consumer] 終了シグナルを受信\n");
                break;
            }
 
            printf("[Consumer] 受信データ: %d\n", shm->data);
            sem_post(&shm->sem_producer);  /* 書き手に次を許可 */
        }
 
        _exit(0);
    }
 
    /* --- 親プロセス（生産者/Producer） --- */
    printf("[Producer PID=%d] 開始\n", getpid());
 
    for (int i = 1; i <= 5; i++) {
        sem_wait(&shm->sem_producer);  /* 書き込み許可を待つ */
 
        shm->data = i * 10;
        printf("[Producer] 送信データ: %d\n", shm->data);
 
        sem_post(&shm->sem_consumer);  /* 読み手にデータ到着を通知 */
        usleep(100000);  /* 100ms待機（動作を見やすくするため） */
    }
 
    /* 終了通知 */
    sem_wait(&shm->sem_producer);
    shm->done = 1;
    sem_post(&shm->sem_consumer);
 
    /* 子プロセスの終了を待つ */
    waitpid(pid, NULL, 0);
 
    /* クリーンアップ */
    sem_destroy(&shm->sem_producer);
    sem_destroy(&shm->sem_consumer);
    munmap(shm, sizeof(shared_data_t));
    shm_unlink(SHM_NAME);
 
    printf("[Producer] 全データの送受信が完了\n");
    return 0;
}

#!/usr/bin/env python3
"""multiprocess_demo.py
Pythonのmultiprocessingモジュールを用いたプロセス間通信のデモ。
 
実行方法: python3 multiprocess_demo.py
 
multiprocessingモジュールは内部的にfork()/exec()やパイプ、
共有メモリなどのOS機構を抽象化して提供している。
"""
import multiprocessing
import os
import time
import sys
 
def producer(queue, count):
    """キューにデータを送信する生産者プロセス。
 
    multiprocessing.Queueは内部的にパイプとロックを使用している。
    プロセス間で安全にデータを受け渡すための高レベルAPIである。
    """
    print(f"[Producer PID={os.getpid()}] 開始")
    for i in range(count):
        item = f"item-{i:03d}"
        queue.put(item)
        print(f"[Producer] 送信: {item}")
        time.sleep(0.1)
    # 終了を示すセンチネル値を送信
    queue.put(None)
    print(f"[Producer] 全アイテム送信完了")
 
def consumer(queue, result_dict, worker_id):
    """キューからデータを受信する消費者プロセス。
 
    result_dictはmultiprocessing.Managerが提供する共有辞書。
    プロセス間で辞書を共有するために、Managerプロセスが仲介する。
    """
    print(f"[Consumer-{worker_id} PID={os.getpid()}] 開始")
    processed = []
    while True:
        item = queue.get()  # データが来るまでブロック
        if item is None:
            # センチネル値を受け取ったら終了
            # 他のConsumerにも終了を伝えるためキューに戻す
            queue.put(None)
            break
        result = f"{item} -> processed by worker-{worker_id}"
        processed.append(result)
        print(f"[Consumer-{worker_id}] 処理: {item}")
        time.sleep(0.05)  # 処理のシミュレーション
 
    result_dict[worker_id] = processed
    print(f"[Consumer-{worker_id}] 終了. 処理件数={len(processed)}")
 
def demo_shared_value():
    """共有メモリを使ったカウンターのデモ。
 
    multiprocessing.Value は内部的にmmap()を使用して
    プロセス間で共有されるメモリ領域を作成している。
    ロックが内蔵されているため、競合状態を自動的に防止する。
    """
    print("\n=== 共有メモリカウンターのデモ ===")
 
    counter = multiprocessing.Value('i', 0)  # 共有整数値
    barrier = multiprocessing.Barrier(4)      # 4プロセスの同期用
 
    def increment(shared_counter, sync_barrier, n):
        """共有カウンターをn回インクリメントする。"""
        sync_barrier.wait()  # 全プロセスの準備完了を待つ
        for _ in range(n):
            with shared_counter.get_lock():
                # get_lock()でロックを取得してから値を変更する。
                # ロックなしだと、読み取り→加算→書き込みの間に
                # 他のプロセスが割り込み、更新が失われる
                # （lost update問題）。
                shared_counter.value += 1
 
    processes = []
    increments_per_process = 10000
    for i in range(4):
        p = multiprocessing.Process(
            target=increment,
            args=(counter, barrier, increments_per_process)
        )
        processes.append(p)
        p.start()
 
    for p in processes:
        p.join()
 
    expected = 4 * increments_per_process
    actual = counter.value
    print(f"期待値: {expected}, 実際値: {actual}")
    if expected == actual:
        print("ロックによる排他制御が正しく機能した")
    else:
        print("競合状態が発生（ロックが不十分）")
 
def main():
    print(f"=== メインプロセス PID={os.getpid()} ===\n")
 
    # === Producer-Consumer パターン ===
    print("=== Producer-Consumer パターン ===")
    queue = multiprocessing.Queue()
 
    # Managerを使ったプロセス間での辞書共有
    manager = multiprocessing.Manager()
    result_dict = manager.dict()
 
    # 1つのProducerと2つのConsumerを起動
    prod = multiprocessing.Process(target=producer, args=(queue, 10))
    cons1 = multiprocessing.Process(target=consumer, args=(queue, result_dict, 1))
    cons2 = multiprocessing.Process(target=consumer, args=(queue, result_dict, 2))
 
    prod.start()
    cons1.start()
    cons2.start()
 
    prod.join()
    cons1.join()
    cons2.join()
 
    print(f"\n処理結果サマリー:")
    for worker_id, items in result_dict.items():
        print(f"  Worker-{worker_id}: {len(items)}件処理")
 
    # === 共有メモリデモ ===
    demo_shared_value()
 
    print(f"\n=== 全デモ完了 ===")
 
if __name__ == "__main__":
    # multiprocessingモジュールを使う場合、
    # __name__ == "__main__" ガードが必須。
    # なぜか？ → fork()やspawn()で子プロセスが生成される際、
    # モジュールが再importされるため、ガードがないと
    # 子プロセスでもmain()が再実行されてしまう。
    main()

/* アンチパターン: wait()を忘れたサーバー */
/* !!!!! このコードは悪い例です !!!!! */
while (1) {
    int client_fd = accept(server_fd, NULL, NULL);
    pid_t pid = fork();
    if (pid == 0) {
        handle_client(client_fd);
        _exit(0);
    }
    close(client_fd);
    /* ここで wait() を呼んでいない！
     * 子プロセスが終了するたびにゾンビが蓄積する。
     * 1日に10,000リクエストを処理するサーバーなら、
     * 1日で10,000個のゾンビが発生する。
     * /proc/sys/kernel/pid_max （通常32768）を超えると
     * fork()がENOSPC/EAGAINで失敗し始める。 */
}
 
/* 正しいパターン: SIGCHLDハンドラで自動回収 */
/* この方法なら、メインループをブロックせずにゾンビを回収できる */
void sigchld_handler(int sig) {
    (void)sig;
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ;  /* 全ての終了済み子プロセスを回収 */
}
 
/* main()の初期化部分で: */
struct sigaction sa;
sa.sa_handler = sigchld_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
sigaction(SIGCHLD, &sa, NULL);

/* アンチパターン: fdリーク */
/* !!!!! このコードは悪い例です !!!!! */
int log_fd = open("/var/log/app.log", O_WRONLY | O_APPEND);
int db_fd = connect_to_database();  /* データベース接続ソケット */
 
pid_t pid = fork();
if (pid == 0) {
    /* 子プロセスは log_fd と db_fd をそのまま継承している。
     * exec()でプログラムを置換しても、FD_CLOEXECが設定されて
     * いなければ、新しいプログラムからこれらのfdにアクセスできる。
     *
     * 問題点:
     * 1. 子プロセスがDB接続を意図せず保持する
     *    → コネクションプールの枯渇
     * 2. ログファイルへの書き込みが競合する可能性
     * 3. セキュリティリスク（子プロセスが信頼されない
     *    プログラムを実行する場合） */
    execvp(cmd[0], cmd);
    _exit(1);
}
 
/* 正しいパターン: 不要なfdをclose、またはO_CLOEXECを使う */
 
/* 方法A: fork後、exec前にclose */
pid_t pid2 = fork();
if (pid2 == 0) {
    close(log_fd);
    close(db_fd);
    execvp(cmd[0], cmd);
    _exit(1);
}
 
/* 方法B: O_CLOEXECフラグ（推奨）
 * ファイルを開く時にO_CLOEXECを設定しておけば、
 * exec()の際に自動的に閉じられる。
 * fork()後にclose()を忘れる心配がない。 */
int safe_fd = open("/var/log/app.log",
                   O_WRONLY | O_APPEND | O_CLOEXEC);

# === 演習1-A: プロセスツリーの確認 ===
# 現在のシステムのプロセスツリーを表示する。
# なぜツリー表示が有用か？ → プロセスの親子関係と、
# どのサービスからどのプロセスが派生したかが一目でわかる。
 
# Linux:
ps auxf                      # ツリー形式で全プロセスを表示
pstree -p                    # PID付きのプロセスツリー
pstree -p $(pgrep sshd | head -1)  # sshd以下のツリーのみ
 
# macOS:
ps aux                       # 全プロセスを表示
pstree                       # Homebrew: brew install pstree
 
# === 演習1-B: /proc からプロセス情報を読む（Linux専用） ===
# /proc は仮想ファイルシステムであり、カーネルがプロセス情報を
# ファイルのように公開している。これにより、特別なAPIを使わず
# 通常のファイル操作でプロセス情報にアクセスできる。
 
cat /proc/self/status       # 自分自身（catプロセス）の情報
cat /proc/self/maps         # メモリマッピング情報
ls -la /proc/self/fd        # 開いているファイルディスクリプタ
cat /proc/self/cmdline | tr '\0' ' '  # コマンドライン引数
cat /proc/self/environ | tr '\0' '\n' | head -20  # 環境変数
 
# 演習課題:
# 1. 自分のシェルプロセスのPIDを確認せよ（echo $$）
# 2. そのPIDの /proc/[PID]/status からプロセス状態を確認せよ
# 3. /proc/[PID]/fd で開いているファイルディスクリプタの数を数えよ
# 4. 新しいファイルを open してから再度 fd の数を確認し、増えたことを確かめよ
 
# === 演習1-C: プロセスの統計情報 ===
# top/htopでリアルタイムのプロセス情報を確認する
top -bn1 | head -20          # バッチモードで1回だけ表示
# htop                       # 対話的なプロセスモニター（要インストール）
 
# プロセスのリソース使用量
/usr/bin/time -v ls /tmp 2>&1  # Linux: 詳細なリソース使用量

# ⚠️ fork爆弾を絶対に実行しないこと。理論的な理解のみ行う。
 
# Bash の fork爆弾:
# :(){ :|:& };:
#
# 展開すると:
# bomb() {
#   bomb | bomb &   # 自分自身を2回呼び出し、バックグラウンドで実行
# }
# bomb              # 最初の呼び出し
#
# なぜ危険か:
# 1回目: 1プロセス → 2プロセス
# 2回目: 2プロセス → 4プロセス
# 3回目: 4プロセス → 8プロセス
# ...
# n回目: 2^n プロセス
# 15回の呼び出しで 32,768プロセス → pid_max に到達
# メモリとCPUが枯渇し、システムが応答不能になる
 
# === 対策1: ulimit でプロセス数を制限 ===
ulimit -u          # 現在のプロセス数上限を確認
ulimit -u 100      # プロセス数上限を100に制限
# この設定は現在のシェルとその子プロセスにのみ適用される
 
# === 対策2: /etc/security/limits.conf で恒久的に制限 ===
# student  hard  nproc  200    # studentユーザーは最大200プロセス
# @users   hard  nproc  500    # usersグループは最大500プロセス
 
# === 対策3: cgroups で制限（systemd環境） ===
# systemd は自動的に各ユーザーセッションにcgroupを割り当てる
# systemctl status user-1000.slice  # UID=1000のユーザーのcgroup
 
# === 対策4: systemd の TasksMax ===
# サービスファイルで制限:
# [Service]
# TasksMax=512    # このサービスのプロセス/スレッド数上限
 
# 演習課題:
# 1. ulimit -u で現在のプロセス数上限を確認せよ
# 2. 上限を50に設定した状態で、多数のバックグラウンドプロセスを
#    生成するスクリプトを書き、上限に達した時の挙動を確認せよ
# 3. cgroups v2 の pids.max ファイルの場所を特定し、値を確認せよ

/* pipeline_exercise.c
 * 演習課題: 以下の骨格コードを完成させ、
 * 3段パイプライン「cat /etc/passwd | grep root | wc -l」
 * を実装せよ。
 *
 * ヒント:
 * - N段パイプラインには N-1 本のパイプが必要
 * - 各子プロセスで適切なfdをdup2で付け替え、
 *   不要なfdを全て閉じること
 * - 親プロセスは全てのパイプfdを閉じ、
 *   全ての子プロセスをwait()すること
 *
 * コンパイル: gcc -Wall -o pipeline_exercise pipeline_exercise.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
 
int main(void)
{
    /* 2本のパイプを作成 */
    int pipe1[2];  /* cat → grep */
    int pipe2[2];  /* grep → wc */
 
    if (pipe(pipe1) < 0 || pipe(pipe2) < 0) {
        perror("pipe");
        return 1;
    }
 
    /* === プロセス1: cat /etc/passwd === */
    pid_t pid1 = fork();
    if (pid1 == 0) {
        /* TODO: 以下を実装せよ
         * 1. stdout を pipe1[1] に付け替える
         * 2. 不要なfd（pipe1[0], pipe2[0], pipe2[1]）を閉じる
         * 3. execlp("cat", "cat", "/etc/passwd", NULL) を実行
         */
 
        /* --- ここにコードを書く --- */
        dup2(pipe1[1], STDOUT_FILENO);
        close(pipe1[0]);
        close(pipe1[1]);
        close(pipe2[0]);
        close(pipe2[1]);
        execlp("cat", "cat", "/etc/passwd", NULL);
        perror("execlp cat");
        _exit(1);
    }
 
    /* === プロセス2: grep root === */
    pid_t pid2 = fork();
    if (pid2 == 0) {
        /* TODO: 以下を実装せよ
         * 1. stdin を pipe1[0] に付け替える
         * 2. stdout を pipe2[1] に付け替える
         * 3. 不要なfd（pipe1[1], pipe2[0]）を閉じる
         * 4. execlp("grep", "grep", "root", NULL) を実行
         */
 
        /* --- ここにコードを書く --- */
        dup2(pipe1[0], STDIN_FILENO);
        dup2(pipe2[1], STDOUT_FILENO);
        close(pipe1[0]);
        close(pipe1[1]);
        close(pipe2[0]);
        close(pipe2[1]);
        execlp("grep", "grep", "root", NULL);
        perror("execlp grep");
        _exit(1);
    }
 
    /* === プロセス3: wc -l === */
    pid_t pid3 = fork();
    if (pid3 == 0) {
        /* TODO: 以下を実装せよ
         * 1. stdin を pipe2[0] に付け替える
         * 2. 不要なfd（pipe1[0], pipe1[1], pipe2[1]）を閉じる
         * 3. execlp("wc", "wc", "-l", NULL) を実行
         */
 
        /* --- ここにコードを書く --- */
        dup2(pipe2[0], STDIN_FILENO);
        close(pipe1[0]);
        close(pipe1[1]);
        close(pipe2[0]);
        close(pipe2[1]);
        execlp("wc", "wc", "-l", NULL);
        perror("execlp wc");
        _exit(1);
    }
 
    /* === 親プロセス: 全fdを閉じて子を待つ === */
    close(pipe1[0]);
    close(pipe1[1]);
    close(pipe2[0]);
    close(pipe2[1]);
 
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);
    waitpid(pid3, NULL, 0);
 
    printf("パイプライン完了\n");
    return 0;
}

# nice値の確認と変更
nice                          # 現在のnice値を表示
nice -n 10 ./heavy_task       # nice値10（低優先度）でプログラムを起動
renice -n -5 -p 1234          # PID 1234のnice値を-5に変更（root権限が必要）
 
# Linux CFS における nice値の効果:
# nice 0 のプロセスの重み: 1024
# nice 1 のプロセスの重み: 820  （約1.25倍遅くなる）
# nice -1 のプロセスの重み: 1277 （約1.25倍速くなる）
# nice値が1つ変わると、相対的なCPU時間が約10%変化する

# 方法1: /proc/[PID]/status（Linux）
grep -E "^(VmSize|VmRSS|VmSwap)" /proc/self/status
# VmSize: 仮想メモリサイズ（マップされた全領域の合計）
# VmRSS:  実際に物理メモリ上にあるサイズ（Resident Set Size）
# VmSwap: スワップアウトされたサイズ
 
# 方法2: ps コマンド
ps -o pid,vsz,rss,comm -p 1234
# VSZ: 仮想メモリサイズ（KB）
# RSS: 物理メモリ使用量（KB）
 
# 方法3: /proc/[PID]/smaps_rollup（Linux 4.14+）
# プロセスの詳細なメモリ統計を確認できる
cat /proc/self/smaps_rollup
 
# 注意: RSSは共有ライブラリのページも含むため、
# プロセス固有のメモリ使用量を正確に知るには PSS
# (Proportional Set Size) を確認する。
# PSSは共有ページをそれを共有するプロセス数で割った値。