プロセス

[C言語] fork()とexec()の違いや使い方を解説

2025-04-14更新日: 2025-04-14

C言語におけるfork()とexec()は、プロセス管理において重要な役割を果たします。

fork()は現在のプロセスを複製し、新しい子プロセスを作成します。これにより、親プロセスと子プロセスが並行して実行されます。

一方、exec()は現在のプロセスの実行イメージを新しいプログラムに置き換えます。これにより、プロセスIDはそのままに、異なるプログラムを実行することが可能です。

これらの関数を組み合わせることで、効率的なプロセス管理が実現できます。

目次から探す

fork()とexec()の基本

fork()とは何か

fork()は、C言語におけるプロセス生成のためのシステムコールです。

この関数を呼び出すと、現在のプロセス(親プロセス)のコピーが作成され、新しいプロセス(子プロセス)が生成されます。

親プロセスと子プロセスは、同じプログラムコードを実行しますが、異なるプロセスIDを持ちます。

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork(); // プロセスを生成
    if (pid == 0) {
        // 子プロセスの処理
        printf("これは子プロセスです。プロセスID: %d\n", getpid());
    } else if (pid > 0) {
        // 親プロセスの処理
        printf("これは親プロセスです。プロセスID: %d\n", getpid());
    } else {
        // fork()のエラー処理
        perror("forkの失敗");
    }
    return 0;
}

これは親プロセスです。プロセスID: 12345
これは子プロセスです。プロセスID: 12346

この例では、fork()を呼び出すことで、親プロセスと子プロセスがそれぞれ異なるメッセージを出力します。

fork()の戻り値を使って、どちらのプロセスであるかを判別します。

exec()とは何か

exec()は、現在のプロセスの実行イメージを新しいプログラムに置き換えるためのシステムコールです。

exec()ファミリーには複数の関数があり、異なる引数の指定方法を提供します。

exec()を呼び出すと、元のプログラムのコードは新しいプログラムに置き換えられ、元のプロセスIDはそのまま維持されます。

#include <stdio.h>
#include <unistd.h>
int main() {
    char *args[] = {"/bin/ls", "-l", NULL}; // 実行するプログラムと引数
    execvp(args[0], args); // プロセスを置き換える
    // exec()が成功すると、ここには戻らない
    perror("execの失敗");
    return 1;
}

total 8
-rw-r--r-- 1 user user 1234 Oct 10 12:34 file1.txt
-rw-r--r-- 1 user user 5678 Oct 10 12:34 file2.txt

この例では、execvp()を使ってls -lコマンドを実行し、現在のプロセスをそのコマンドに置き換えます。

プロセスとスレッドの違い

特徴	プロセス	スレッド
定義	独立した実行単位	プロセス内の軽量な実行単位
メモリ空間	各プロセスは独立したメモリ空間を持つ	同じプロセス内でメモリ空間を共有
通信	プロセス間通信(IPC)が必要	共有メモリを通じて容易に通信可能
オーバーヘッド	高い	低い

プロセスは独立した実行単位であり、各プロセスは独自のメモリ空間を持ちます。

一方、スレッドは同じプロセス内で実行され、メモリ空間を共有します。

これにより、スレッド間の通信はプロセス間通信よりも効率的です。

fork()とexec()の関係性

fork()とexec()は、プロセス管理において密接に関連しています。

fork()を使って新しいプロセスを生成し、その後exec()を使ってそのプロセスを新しいプログラムに置き換えるというのが一般的な使い方です。

これにより、親プロセスは子プロセスを生成し、子プロセスは別のプログラムを実行することができます。

この組み合わせは、シェルやサーバープログラムなどでよく利用されます。

fork()の使い方

fork()の基本的な使用例

fork()は、プロセスを複製するための基本的なシステムコールです。

以下の例では、fork()を使って親プロセスから子プロセスを生成し、それぞれが異なるメッセージを出力します。

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork(); // プロセスを生成
    if (pid == 0) {
        // 子プロセスの処理
        printf("子プロセス: プロセスID = %d\n", getpid());
    } else if (pid > 0) {
        // 親プロセスの処理
        printf("親プロセス: プロセスID = %d\n", getpid());
    } else {
        // fork()のエラー処理
        perror("forkの失敗");
    }
    return 0;
}

親プロセス: プロセスID = 12345
子プロセス: プロセスID = 12346

この例では、fork()を呼び出すことで、親プロセスと子プロセスがそれぞれのメッセージを出力します。

fork()の戻り値の解釈

fork()の戻り値は、プロセスの役割を決定するために重要です。

以下の表に、fork()の戻り値とその意味を示します。

戻り値	意味
0	子プロセスであることを示す
正の値	親プロセスであり、子プロセスのPIDを示す
負の値	エラーが発生したことを示す

親プロセスは、fork()の戻り値として子プロセスのプロセスIDを受け取ります。

一方、子プロセスは常に0を受け取ります。

エラーが発生した場合、fork()は負の値を返します。

親プロセスと子プロセスの違い

親プロセスと子プロセスは、fork()によって生成されるが、いくつかの違いがあります。

プロセスID: 親プロセスと子プロセスは異なるプロセスIDを持ちます。
親プロセスID: 子プロセスの親プロセスIDは、親プロセスのプロセスIDと同じです。
メモリ空間: 子プロセスは親プロセスのメモリ空間をコピーしますが、独立したメモリ空間を持ちます。

これにより、親プロセスと子プロセスは独立して動作し、異なるタスクを実行することができます。

fork()のエラーハンドリング

fork()が失敗する場合、システムリソースが不足していることが原因であることが多いです。

エラーハンドリングは、fork()の戻り値が負の値であるかどうかを確認することで行います。

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid < 0) {
        // fork()のエラー処理
        perror("forkの失敗");
        return 1;
    } else if (pid == 0) {
        // 子プロセスの処理
        printf("子プロセス: プロセスID = %d\n", getpid());
    } else {
        // 親プロセスの処理
        printf("親プロセス: プロセスID = %d\n", getpid());
    }
    return 0;
}

この例では、fork()が負の値を返した場合にエラーメッセージを出力し、プログラムを終了します。

エラーハンドリングを適切に行うことで、予期しない動作を防ぐことができます。

exec()の使い方

exec()ファミリーの関数一覧

exec()ファミリーは、現在のプロセスの実行イメージを新しいプログラムに置き換えるための一連の関数です。

これらの関数は、異なる引数の指定方法を提供します。

以下に、exec()ファミリーの主な関数を示します。

関数名	説明
`execl()`	可変長引数リストを使用してプログラムを実行
`execlp()`	`PATH`環境変数を使用してプログラムを検索
`execle()`	環境変数を指定してプログラムを実行
`execv()`	配列で引数を指定してプログラムを実行
`execvp()`	`PATH`環境変数を使用し、配列で引数を指定
`execve()`	配列で引数と環境変数を指定してプログラムを実行

これらの関数は、プログラムの実行方法や環境変数の指定方法に応じて使い分けます。

exec()の基本的な使用例

exec()を使用することで、現在のプロセスを新しいプログラムに置き換えることができます。

以下の例では、execvp()を使ってls -lコマンドを実行します。

#include <stdio.h>
#include <unistd.h>
int main() {
    char *args[] = {"/bin/ls", "-l", NULL}; // 実行するプログラムと引数
    execvp(args[0], args); // プロセスを置き換える
    // exec()が成功すると、ここには戻らない
    perror("execの失敗");
    return 1;
}

total 8
-rw-r--r-- 1 user user 1234 Oct 10 12:34 file1.txt
-rw-r--r-- 1 user user 5678 Oct 10 12:34 file2.txt

この例では、execvp()を使ってls -lコマンドを実行し、現在のプロセスをそのコマンドに置き換えます。

exec()の引数と環境変数

exec()ファミリーの関数は、プログラムの引数と環境変数を指定する方法が異なります。

以下に、execve()を使用した例を示します。

#include <stdio.h>
#include <unistd.h>
int main() {
    char *args[] = {"/bin/ls", "-l", NULL}; // 実行するプログラムと引数
    char *env[] = {"PATH=/bin", NULL}; // 環境変数
    execve(args[0], args, env); // プロセスを置き換える
    // exec()が成功すると、ここには戻らない
    perror("execの失敗");
    return 1;
}

この例では、execve()を使ってls -lコマンドを実行し、環境変数を指定しています。

execve()は、引数と環境変数の両方を配列で指定することができます。

exec()のエラーハンドリング

exec()ファミリーの関数は、成功すると戻りません。

したがって、エラーハンドリングは、exec()が失敗した場合にのみ行われます。

失敗した場合、exec()は-1を返し、errnoにエラーの詳細が設定されます。

#include <stdio.h>
#include <unistd.h>
int main() {
    char *args[] = {"/bin/ls", "-l", NULL}; // 実行するプログラムと引数
    if (execvp(args[0], args) == -1) {
        // exec()のエラー処理
        perror("execの失敗");
        return 1;
    }
    return 0;
}

この例では、execvp()が失敗した場合にエラーメッセージを出力します。

エラーハンドリングを適切に行うことで、プログラムの予期しない終了を防ぐことができます。

fork()とexec()の組み合わせ

fork()とexec()を組み合わせる理由

fork()とexec()を組み合わせることで、親プロセスが子プロセスを生成し、その子プロセスが別のプログラムを実行するというプロセス管理が可能になります。

この組み合わせは、以下のような理由で重要です。

プロセス分離: 親プロセスと子プロセスを分離することで、異なるタスクを並行して実行できます。
リソース管理: 親プロセスは子プロセスの終了を待機し、リソースを適切に管理できます。
柔軟性: 子プロセスを生成した後、exec()を使って任意のプログラムを実行できるため、柔軟なプログラム設計が可能です。

プロセスの置き換え

exec()を使うことで、子プロセスの実行イメージを新しいプログラムに置き換えることができます。

これにより、子プロセスは親プロセスとは異なるプログラムを実行することができます。

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork(); // プロセスを生成
    if (pid == 0) {
        // 子プロセスで新しいプログラムを実行
        char *args[] = {"/bin/ls", "-l", NULL};
        execvp(args[0], args);
        // exec()が成功すると、ここには戻らない
        perror("execの失敗");
        return 1;
    } else if (pid > 0) {
        // 親プロセスの処理
        printf("親プロセス: 子プロセスを生成しました。\n");
    } else {
        // fork()のエラー処理
        perror("forkの失敗");
    }
    return 0;
}

この例では、親プロセスが子プロセスを生成し、子プロセスがls -lコマンドを実行します。

実際の使用例：シェルの実装

シェルは、ユーザーからのコマンドを受け取り、それを実行するプログラムです。

シェルの実装では、fork()とexec()を組み合わせて、ユーザーが入力したコマンドを新しいプロセスで実行します。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main() {
    char command[256];
    while (1) {
        printf("シェル> ");
        fgets(command, sizeof(command), stdin);
        command[strcspn(command, "\n")] = '\0'; // 改行を削除
        if (strcmp(command, "exit") == 0) {
            break; // シェルを終了
        }
        pid_t pid = fork();
        if (pid == 0) {
            // 子プロセスでコマンドを実行
            char *args[] = {command, NULL};
            execvp(args[0], args);
            // exec()が成功すると、ここには戻らない
            perror("execの失敗");
            return 1;
        } else if (pid > 0) {
            // 親プロセスは子プロセスの終了を待つ
            wait(NULL);
        } else {
            perror("forkの失敗");
        }
    }
    return 0;
}

このシンプルなシェルの例では、ユーザーが入力したコマンドをfork()で生成した子プロセスで実行し、execvp()で置き換えます。

fork()とexec()のパフォーマンス考慮

fork()とexec()を使用する際には、パフォーマンスに関する考慮が必要です。

コピーオンライト: fork()は、コピーオンライト技術を使用してメモリを効率的に管理します。

これにより、親プロセスと子プロセスが同じメモリ空間を共有し、変更があるまで実際のコピーは行われません。

プロセス生成のオーバーヘッド: プロセス生成にはオーバーヘッドが伴います。

頻繁にプロセスを生成する場合、パフォーマンスに影響を与える可能性があります。

リソースの適切な管理: 親プロセスは、子プロセスの終了を待機し、リソースを適切に解放する必要があります。

これにより、システムリソースの無駄遣いを防ぎます。

これらの考慮事項を踏まえて、fork()とexec()を効果的に使用することが重要です。

応用例

マルチプロセスプログラミング

マルチプロセスプログラミングは、複数のプロセスを同時に実行することで、プログラムのパフォーマンスを向上させる手法です。

fork()を使用して複数の子プロセスを生成し、それぞれが独立したタスクを実行することができます。

以下は、マルチプロセスプログラミングの基本的な例です。

#include <stdio.h>
#include <unistd.h>
int main() {
    for (int i = 0; i < 3; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            // 子プロセスの処理
            printf("子プロセス %d: プロセスID = %d\n", i, getpid());
            return 0;
        }
    }
    // 親プロセスの処理
    printf("親プロセス: 子プロセスを生成しました。\n");
    return 0;
}

この例では、3つの子プロセスを生成し、それぞれが独立して動作します。

親プロセスは、子プロセスの生成を管理します。

サーバープログラムでの使用

サーバープログラムでは、fork()を使用して新しいクライアント接続ごとに子プロセスを生成し、クライアントのリクエストを処理します。

これにより、サーバーは複数のクライアントを同時に処理することができます。

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    // ソケットの作成とバインド
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);
    bind(server_fd, (struct sockaddr *)&address, sizeof(address));
    listen(server_fd, 3);
    while (1) {
        new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
        if (fork() == 0) {
            // 子プロセスでクライアントを処理
            printf("クライアント接続を処理中: プロセスID = %d\n", getpid());
            close(new_socket);
            return 0;
        }
        close(new_socket);
    }
    return 0;
}

この例では、サーバーは新しいクライアント接続ごとに子プロセスを生成し、クライアントのリクエストを処理します。

並列処理の実装

並列処理は、複数のプロセスを同時に実行することで、計算タスクを効率的に処理する手法です。

fork()を使用して複数のプロセスを生成し、各プロセスが異なる計算タスクを実行します。

#include <stdio.h>
#include <unistd.h>
void perform_task(int task_id) {
    printf("タスク %d を処理中: プロセスID = %d\n", task_id, getpid());
    // タスクの処理をシミュレート
    sleep(1);
}
int main() {
    for (int i = 0; i < 4; i++) {
        if (fork() == 0) {
            // 子プロセスでタスクを実行
            perform_task(i);
            return 0;
        }
    }
    // 親プロセスの処理
    printf("親プロセス: 全てのタスクを開始しました。\n");
    return 0;
}

この例では、4つの子プロセスを生成し、それぞれが異なるタスクを並列に処理します。

プロセス間通信(IPC)との組み合わせ

プロセス間通信(IPC)は、複数のプロセス間でデータをやり取りするための手法です。

fork()で生成したプロセス間でデータを共有するために、パイプや共有メモリなどのIPCメカニズムを使用します。

#include <stdio.h>
#include <unistd.h>
int main() {
    int pipefd[2];
    pipe(pipefd); // パイプを作成
    if (fork() == 0) {
        // 子プロセスの処理
        close(pipefd[0]); // 読み取り用のファイルディスクリプタを閉じる
        char message[] = "こんにちは、親プロセス！";
        write(pipefd[1], message, sizeof(message));
        close(pipefd[1]);
    } else {
        // 親プロセスの処理
        close(pipefd[1]); // 書き込み用のファイルディスクリプタを閉じる
        char buffer[256];
        read(pipefd[0], buffer, sizeof(buffer));
        printf("親プロセスが受信: %s\n", buffer);
        close(pipefd[0]);
    }
    return 0;
}