c语言如何创建多个进程

在C语言中创建多个进程的核心在于：使用fork函数、管理子进程、处理进程间通信。 fork函数是Unix和Linux系统中用于创建新进程的基本方法。下面将详细介绍如何在C语言中使用fork函数创建多个进程，并管理这些进程的生命周期。

一、使用`fork`函数创建进程

1. `fork`函数的基本使用

fork函数是Unix和Linux系统中用于创建新进程的基本方法。调用fork函数时，当前进程将被复制，生成一个新的子进程。父进程和子进程的执行路径相同，但它们的进程ID不同。

#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("This is the child process with PID: %dn", getpid());
    } else {
        // 父进程执行的代码
        printf("This is the parent process with PID: %dn", getpid());
    }
    return 0;
}

2. 创建多个子进程

为了创建多个子进程，可以在一个循环中多次调用fork函数，每次循环都会生成一个新的子进程。

#include <stdio.h>
#include <unistd.h>
int main() {
    int i;
    for (i = 0; i < 3; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork failed");
            return 1;
        } else if (pid == 0) {
            printf("Child %d: PID = %d, PPID = %dn", i, getpid(), getppid());
            return 0;  // 子进程返回
        }
    }
    // 父进程等待所有子进程退出
    for (i = 0; i < 3; i++) {
        wait(NULL);
    }
    return 0;
}

二、进程间通信

1. 管道（Pipe）

管道是一种古老而常用的进程间通信（IPC）方式，它允许一个进程将数据写入管道，另一个进程从管道读取数据。使用pipe函数可以创建一个无名管道。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main() {
    int fd[2];
    pid_t pid;
    char buffer[30];
    if (pipe(fd) == -1) {
        perror("pipe failed");
        return 1;
    }
    pid = fork();
    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程写入管道
        close(fd[0]);  // 关闭读端
        write(fd[1], "Hello from child", 17);
        close(fd[1]);
    } else {
        // 父进程读取管道
        close(fd[1]);  // 关闭写端
        read(fd[0], buffer, sizeof(buffer));
        printf("Parent received: %sn", buffer);
        close(fd[0]);
    }
    return 0;
}

2. 共享内存

共享内存是一种高效的进程间通信方式，它允许多个进程访问同一个内存段。使用shmget和shmat函数可以创建和附加共享内存。

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
int main() {
    key_t key = 1234;
    int shmid = shmget(key, 1024, 0666|IPC_CREAT);
    if (shmid == -1) {
        perror("shmget failed");
        return 1;
    }
    char *str = (char*) shmat(shmid, NULL, 0);
    if (str == (char*) -1) {
        perror("shmat failed");
        return 1;
    }
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程写入共享内存
        strcpy(str, "Hello from child");
    } else {
        // 父进程读取共享内存
        wait(NULL);
        printf("Parent received: %sn", str);
        shmdt(str);
        shmctl(shmid, IPC_RMID, NULL);
    }
    return 0;
}

三、进程管理和同步

1. `wait`和`waitpid`函数

wait和waitpid函数用于等待子进程终止，并获取其终止状态。wait函数等待任意子进程终止，而waitpid函数可以指定等待的子进程。

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Child process PID: %dn", getpid());
        sleep(2);  // 模拟子进程工作
        return 0;
    } else {
        // 父进程
        int status;
        wait(&status);
        if (WIFEXITED(status)) {
            printf("Child exited with status: %dn", WEXITSTATUS(status));
        }
    }
    return 0;
}

2. 信号（Signal）

信号是进程间通信的一种方式，用于通知进程某种事件的发生。常用信号包括SIGINT、SIGTERM等。使用signal或sigaction函数可以设置信号处理器。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
void handle_sigint(int sig) {
    printf("Caught signal %dn", sig);
}
int main() {
    signal(SIGINT, handle_sigint);
    while (1) {
        printf("Running...n");
        sleep(1);
    }
    return 0;
}

四、实战案例：多进程计算

1. 任务分配

假设我们需要计算一个大型数组的平方和，可以将任务分配给多个子进程，每个子进程计算一部分结果，然后汇总到父进程。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define SIZE 1000
#define NUM_PROCESSES 4
void calculate_partial_sum(int *array, int start, int end, int *result) {
    int sum = 0;
    for (int i = start; i < end; i++) {
        sum += array[i] * array[i];
    }
    *result = sum;
}
int main() {
    int array[SIZE];
    for (int i = 0; i < SIZE; i++) {
        array[i] = i + 1;
    }
    int fd[2];
    if (pipe(fd) == -1) {
        perror("pipe failed");
        return 1;
    }
    int segment = SIZE / NUM_PROCESSES;
    pid_t pid;
    for (int i = 0; i < NUM_PROCESSES; i++) {
        pid = fork();
        if (pid == 0) {
            close(fd[0]);
            int partial_sum;
            calculate_partial_sum(array, i * segment, (i + 1) * segment, &partial_sum);
            write(fd[1], &partial_sum, sizeof(int));
            close(fd[1]);
            return 0;
        } else if (pid < 0) {
            perror("fork failed");
            return 1;
        }
    }
    close(fd[1]);
    int total_sum = 0;
    int partial_sum;
    for (int i = 0; i < NUM_PROCESSES; i++) {
        read(fd[0], &partial_sum, sizeof(int));
        total_sum += partial_sum;
    }
    close(fd[0]);
    for (int i = 0; i < NUM_PROCESSES; i++) {
        wait(NULL);
    }
    printf("Total sum of squares: %dn", total_sum);
    return 0;
}

通过以上案例，我们可以看到如何在C语言中创建多个进程，并通过管道进行数据传递和结果汇总。使用fork函数创建多个进程、通过管道或共享内存进行进程间通信、使用wait和信号进行进程管理和同步，这些技术都是多进程编程的核心内容。通过合理运用这些技术，可以充分利用多核处理器的计算能力，提高程序的并行处理性能。

在实际开发中，为了更好地管理和协调多个进程，还可以借助一些专业的项目管理工具，如研发项目管理系统PingCode和通用项目管理软件Worktile，这些工具可以帮助团队更高效地分配任务、跟踪进度和协作开发。