[C言語] 並列処理ができるfork関数の使い方を解説

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork(); // 新しいプロセスを生成
    if (pid < 0) {
        // forkが失敗した場合
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子プロセスの処理
        printf("これは子プロセスです。PID: %d\n", getpid());
    } else {
        // 親プロセスの処理
        printf("これは親プロセスです。PID: %d\n", getpid());
    }
    return 0;
}

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

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子プロセスの処理
        printf("子プロセス: データを処理中...\n");
        // データ処理のコード
    } else {
        // 親プロセスの処理
        printf("親プロセス: ファイルを読み込み中...\n");
        // ファイル読み込みのコード
    }
    return 0;
}

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

子プロセスが受信: こんにちは、子プロセス！

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子プロセスの処理
        printf("子プロセスが終了します。\n");
        return 42; // 終了ステータス
    } else {
        // 親プロセスの処理
        int status;
        wait(&status); // 子プロセスの終了を待つ
        if (WIFEXITED(status)) {
            printf("子プロセスが終了しました。ステータス: %d\n", WEXITSTATUS(status));
        }
    }
    return 0;
}

子プロセスが終了します。
子プロセスが終了しました。ステータス: 42

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid < 0) {
        // forkが失敗した場合
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子プロセスの処理
        printf("子プロセスが実行中です。\n");
    } else {
        // 親プロセスの処理
        printf("親プロセスが実行中です。\n");
    }
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
void performTask(int taskNumber) {
    printf("プロセス %d がタスク %d を実行中です。\n", getpid(), taskNumber);
    // タスクの処理をここに記述
}
int main() {
    const int numTasks = 3;
    pid_t pids[numTasks];
    for (int i = 0; i < numTasks; i++) {
        pids[i] = fork();
        if (pids[i] < 0) {
            perror("fork failed");
            return 1;
        } else if (pids[i] == 0) {
            // 子プロセスの処理
            performTask(i);
            return 0; // 子プロセスはここで終了
        }
    }
    // 親プロセスはすべての子プロセスの終了を待つ
    for (int i = 0; i < numTasks; i++) {
        waitpid(pids[i], NULL, 0);
    }
    printf("すべてのタスクが完了しました。\n");
    return 0;
}

プロセス 12347 がタスク 0 を実行中です。
プロセス 12348 がタスク 1 を実行中です。
プロセス 12349 がタスク 2 を実行中です。
すべてのタスクが完了しました。

#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) {
            // 子プロセス: クライアントの接続を処理
            close(server_fd);
            // クライアントとの通信処理
            close(new_socket);
            return 0;
        }
        close(new_socket);
    }
    return 0;
}

#include <stdio.h>
#include <unistd.h>
void processBatch(int batchNumber) {
    printf("バッチ %d を処理中です。\n", batchNumber);
    // バッチ処理のコード
}
int main() {
    const int numBatches = 5;
    for (int i = 0; i < numBatches; i++) {
        if (fork() == 0) {
            // 子プロセス: バッチを処理
            processBatch(i);
            return 0;
        }
    }
    // 親プロセスはすべての子プロセスの終了を待つ
    for (int i = 0; i < numBatches; i++) {
        wait(NULL);
    }
    printf("すべてのバッチ処理が完了しました。\n");
    return 0;
}

#include <stdio.h>
#include <unistd.h>
void performHeavyTask(int taskNumber) {
    printf("重いタスク %d を実行中です。\n", taskNumber);
    // 重いタスクの処理
}
int main() {
    const int numTasks = 4;
    for (int i = 0; i < numTasks; i++) {
        if (fork() == 0) {
            // 子プロセス: 重いタスクを実行
            performHeavyTask(i);
            return 0;
        }
    }
    // 親プロセスはすべての子プロセスの終了を待つ
    for (int i = 0; i < numTasks; i++) {
        wait(NULL);
    }
    printf("すべての重いタスクが完了しました。\n");
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
void handleTask() {
    printf("プロセス %d がタスクを処理中です。\n", getpid());
    // タスクの処理
}
int main() {
    const int poolSize = 3;
    pid_t pids[poolSize];
    for (int i = 0; i < poolSize; i++) {
        if ((pids[i] = fork()) == 0) {
            // 子プロセス: タスクを処理
            handleTask();
            return 0;
        }
    }
    // 親プロセスはすべての子プロセスの終了を待つ
    for (int i = 0; i < poolSize; i++) {
        waitpid(pids[i], NULL, 0);
    }
    printf("すべてのタスクがプロセスプールで処理されました。\n");
    return 0;
}