Linux C语言多进程创建的流程
2023-11-273.4k 阅读
进程的基本概念
在深入探讨 Linux C 语言多进程创建流程之前，我们先来了解一下进程的基本概念。进程是操作系统进行资源分配和调度的基本单位，它代表着一个正在执行的程序实例。每个进程都有自己独立的地址空间、代码段、数据段、堆栈段等资源。
进程的生命周期
进程从创建开始，经历运行、暂停、继续等状态，最终结束并释放资源。其典型的生命周期包括以下几个阶段：
- 创建阶段：由父进程调用相关系统函数（如
fork）创建一个新的子进程。新创建的子进程几乎是父进程的一个副本，包括内存空间、文件描述符等资源的复制。 - 运行阶段：进程获得 CPU 时间片，其代码在 CPU 上执行，进行各种计算、数据处理、I/O 操作等任务。
- 暂停阶段：进程可能会因为等待某些事件（如 I/O 完成、信号处理等）而暂停执行，此时进程处于等待状态，不会占用 CPU 时间片。
- 继续阶段：当等待的事件发生后，进程从暂停状态恢复到运行状态，继续执行其代码。
- 结束阶段：进程完成其任务或者因为某些错误而终止，操作系统回收该进程占用的所有资源，如内存、文件描述符等。
进程与程序的区别
程序是静态的，它是一组指令和数据的集合，存储在磁盘等外部存储设备上。而进程是动态的，是程序在执行过程中的实例，它在内存中运行，具有自己独立的资源和状态。同一个程序可以同时运行多个进程实例，每个实例都有自己独立的地址空间和执行上下文。例如，我们可以同时打开多个文本编辑器程序，每个打开的文本编辑器就是该程序的一个进程实例，它们之间相互独立，各自处理不同的文档。
Linux 系统下进程相关的系统调用
在 Linux 系统中，提供了一系列系统调用来管理进程，其中与多进程创建密切相关的系统调用主要有 fork、exec 系列函数等。
fork 系统调用
fork 是 Linux 系统中用于创建新进程的最基本系统调用。其函数原型如下：
#include <unistd.h>
pid_t fork(void);
fork 函数调用成功后，会在父进程中返回子进程的进程 ID（PID），而在子进程中返回 0。如果 fork 调用失败，则返回 -1，并设置 errno 以指示错误原因。例如，errno 可能被设置为 EAGAIN 表示系统资源不足无法创建新进程，或者 ENOMEM 表示内存不足。
下面是一个简单的使用 fork 函数的代码示例：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
pid_t pid;
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
printf("I am the child process. My PID is %d, and my parent's PID is %d\n", getpid(), getppid());
} else {
printf("I am the parent process. My PID is %d, and my child's PID is %d\n", getpid(), pid);
}
return 0;
}
在上述代码中，父进程调用 fork 创建子进程。如果 fork 成功，父子进程都会继续执行后续代码。通过 pid 的值来区分父子进程，父进程中 pid 为子进程的 PID，子进程中 pid 为 0。getpid 函数用于获取当前进程的 PID，getppid 函数用于获取当前进程父进程的 PID。
exec 系列函数
exec 系列函数用于在当前进程的上下文中执行一个新的程序。当一个进程调用 exec 函数时，该进程的用户空间代码和数据被新程序替换，从新程序的启动例程开始执行。但进程的 PID 保持不变，这意味着调用 exec 并没有创建新的进程，而是替换了当前进程的执行内容。
exec 系列函数有多个变体，常用的有 execl、execv、execle、execve、execlp、execvp 等。以 execl 为例，其函数原型如下：
#include <unistd.h>
int execl(const char *path, const char *arg0, ... /* (char *) NULL */);
path 参数指定要执行的程序的路径，arg0 是传递给新程序的第一个参数，通常为程序名本身，后续参数以可变参数列表的形式给出，最后一个参数必须为 NULL，以表示参数列表的结束。
下面是一个使用 execl 的示例代码：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
pid_t pid;
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
// 子进程执行 ls 命令
if (execl("/bin/ls", "ls", "-l", NULL) == -1) {
perror("execl error");
exit(1);
}
} else {
wait(NULL); // 父进程等待子进程结束
printf("Child process has finished.\n");
}
return 0;
}
在这个示例中，父进程创建子进程后，子进程调用 execl 执行 /bin/ls 程序，并传递参数 -l，从而实现列出当前目录下文件的详细信息。父进程通过 wait 函数等待子进程结束。
Linux C 语言多进程创建的详细流程
单个进程创建流程
- 调用 fork 函数：在父进程的代码中调用
fork系统调用。fork函数在内核空间执行一系列操作，包括为子进程分配进程控制块（PCB）等资源。 - 复制资源：内核将父进程的大部分资源，如内存空间（通过写时复制技术，COW，Copy - On - Write，即只有在父子进程中有一方试图修改内存时才真正复制内存页）、文件描述符表等，复制到子进程对应的资源结构中。
- 返回值处理：
fork函数返回后，父进程得到子进程的 PID，子进程得到 0。父子进程根据返回值来执行不同的代码逻辑。例如，父进程可能继续执行其原有的任务，同时可以通过子进程的 PID 对其进行管理（如等待子进程结束、发送信号等）；子进程则可以根据需要执行特定的任务，如调用exec系列函数加载并执行新的程序。
多进程创建的一般模式
在实际应用中，常常需要创建多个子进程来完成复杂的任务。多进程创建的一般模式如下：
- 循环创建子进程：父进程通过一个循环多次调用
fork函数，每次调用都会创建一个新的子进程。例如：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#define CHILD_PROCESS_COUNT 3
int main() {
pid_t pid;
int i;
for (i = 0; i < CHILD_PROCESS_COUNT; i++) {
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
printf("I am child process %d. My PID is %d\n", i, getpid());
exit(0);
}
}
// 父进程等待所有子进程结束
for (i = 0; i < CHILD_PROCESS_COUNT; i++) {
wait(NULL);
}
printf("All child processes have finished.\n");
return 0;
}
在上述代码中，父进程通过循环创建了 CHILD_PROCESS_COUNT 个（这里为 3 个）子进程。每个子进程输出自己的序号和 PID 后结束。父进程通过另一个循环调用 wait 函数等待所有子进程结束。
2. 子进程分工：不同的子进程可以根据需要执行不同的任务。例如，在一个服务器程序中，可能会创建多个子进程，每个子进程负责处理一个客户端连接。子进程可以在创建后根据自身的进程 ID 或者全局变量来确定自己的任务。例如：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#define CHILD_PROCESS_COUNT 3
int main() {
pid_t pid;
int i;
for (i = 0; i < CHILD_PROCESS_COUNT; i++) {
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
if (i == 0) {
// 子进程 0 执行特定任务
printf("Child process 0 is doing task 0\n");
} else if (i == 1) {
// 子进程 1 执行特定任务
printf("Child process 1 is doing task 1\n");
} else {
// 子进程 2 执行特定任务
printf("Child process 2 is doing task 2\n");
}
exit(0);
}
}
// 父进程等待所有子进程结束
for (i = 0; i < CHILD_PROCESS_COUNT; i++) {
wait(NULL);
}
printf("All child processes have finished.\n");
return 0;
}
- 进程间通信与同步：多个子进程之间以及子进程与父进程之间可能需要进行通信和同步。常见的进程间通信（IPC）方式包括管道（pipe）、消息队列、共享内存、信号量等。例如，使用管道进行父子进程间通信：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#define BUFFER_SIZE 100
int main() {
int pipe_fd[2];
pid_t pid;
char buffer[BUFFER_SIZE];
if (pipe(pipe_fd) == -1) {
perror("pipe error");
exit(1);
}
pid = fork();
if (pid < 0) {
perror("fork error");
close(pipe_fd[0]);
close(pipe_fd[1]);
exit(1);
} else if (pid == 0) {
// 子进程向管道写入数据
close(pipe_fd[0]);
const char *message = "Hello from child";
write(pipe_fd[1], message, strlen(message));
close(pipe_fd[1]);
} else {
// 父进程从管道读取数据
close(pipe_fd[1]);
ssize_t bytes_read = read(pipe_fd[0], buffer, BUFFER_SIZE - 1);
if (bytes_read > 0) {
buffer[bytes_read] = '\0';
printf("Parent received: %s\n", buffer);
}
close(pipe_fd[0]);
}
return 0;
}
在上述代码中，首先创建一个管道 pipe_fd。子进程关闭读端 pipe_fd[0]，向管道写端 pipe_fd[1] 写入数据；父进程关闭写端 pipe_fd[1]，从管道读端 pipe_fd[0] 读取数据。通过这种方式实现了父子进程间的简单通信。
多进程创建中的资源管理
- 文件描述符管理：在进程创建时，子进程会继承父进程的文件描述符表。这意味着父子进程可以共享打开的文件。然而，在实际应用中，需要根据具体需求合理关闭不需要的文件描述符。例如，在上述管道通信的例子中，子进程不需要读端的文件描述符，父进程不需要写端的文件描述符，因此分别关闭了相应的文件描述符，以避免资源浪费和潜在的错误。
- 内存管理：由于采用写时复制技术，父子进程在开始时共享相同的内存页，只有当其中一方试图修改内存时才会进行内存复制。但如果子进程调用
exec系列函数，会完全替换当前进程的内存空间，加载新程序的代码和数据。在编写多进程程序时，要注意内存的使用情况，避免内存泄漏和非法访问。例如，如果父进程在创建子进程前分配了动态内存，子进程继承了指向该内存的指针，但如果子进程在修改该内存前没有意识到写时复制的机制，可能会导致意外的结果。因此，在涉及内存操作时，需要谨慎处理父子进程间的内存关系。
处理进程创建失败的情况
在调用 fork 或 exec 系列函数时，可能会因为各种原因失败。例如，系统资源不足、权限问题等。当 fork 失败时，会返回 -1，并设置 errno 来指示错误原因。常见的错误原因包括：
- 系统资源不足（
EAGAIN）：系统无法分配足够的资源来创建新进程，如内存不足、进程表已满等。此时，应用程序可以选择等待一段时间后重试，或者提示用户系统资源不足。 - 内存不足（
ENOMEM）：内核无法为新进程分配必要的内存空间。这可能需要应用程序优化内存使用，或者请求用户关闭其他占用大量内存的程序。 在代码中，可以通过检查返回值和errno来处理这些错误情况，例如：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
int main() {
pid_t pid;
pid = fork();
if (pid < 0) {
if (errno == EAGAIN) {
printf("System resources are insufficient. Try again later.\n");
} else if (errno == ENOMEM) {
printf("Memory is insufficient. Please close other applications.\n");
} else {
perror("fork error");
}
exit(1);
} else if (pid == 0) {
printf("I am the child process.\n");
} else {
printf("I am the parent process.\n");
}
return 0;
}
同样，对于 exec 系列函数，如果调用失败，也会返回 -1，并设置 errno。常见的错误原因包括文件不存在（ENOENT）、权限不足（EACCES）等。例如：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
int main() {
pid_t pid;
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
if (execl("/nonexistent_program", "nonexistent_program", NULL) == -1) {
if (errno == ENOENT) {
printf("The program does not exist.\n");
} else if (errno == EACCES) {
printf("Permission denied.\n");
} else {
perror("execl error");
}
exit(1);
}
} else {
wait(NULL);
printf("Child process has finished.\n");
}
return 0;
}
在上述代码中，子进程尝试执行一个不存在的程序，通过检查 errno 来判断错误原因并给出相应提示。
多进程编程中的常见问题与解决方案
竞争条件与同步问题
- 竞争条件：当多个进程同时访问和修改共享资源（如共享内存、文件等）时，可能会出现竞争条件。例如，多个子进程同时向一个文件写入数据，如果没有适当的同步机制，可能会导致数据混乱。假设两个子进程都读取文件中的某个数值，然后各自对其加 1 并写回文件，由于两个进程的操作不是原子的，可能会导致最终文件中的数值只增加了 1，而不是预期的 2。
- 同步解决方案：为了解决竞争条件，可以使用同步机制，如信号量。信号量是一个整型变量，它可以用来控制对共享资源的访问。例如，通过创建一个初始值为 1 的信号量，当一个进程要访问共享资源时，先获取信号量（将信号量值减 1），访问完后释放信号量（将信号量值加 1）。这样，其他进程在信号量值为 0 时就无法获取信号量，从而保证同一时间只有一个进程能访问共享资源。下面是一个使用信号量进行进程同步的简单示例：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/types.h>
// 信号量操作函数
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
};
void semaphore_down(int semid) {
struct sembuf sem_op;
sem_op.sem_num = 0;
sem_op.sem_op = -1;
sem_op.sem_flg = 0;
semop(semid, &sem_op, 1);
}
void semaphore_up(int semid) {
struct sembuf sem_op;
sem_op.sem_num = 0;
sem_op.sem_op = 1;
sem_op.sem_flg = 0;
semop(semid, &sem_op, 1);
}
int main() {
key_t key;
int semid;
pid_t pid;
key = ftok(".", 'a');
if (key == -1) {
perror("ftok error");
exit(1);
}
semid = semget(key, 1, IPC_CREAT | 0666);
if (semid == -1) {
perror("semget error");
exit(1);
}
union semun sem_set;
sem_set.val = 1;
if (semctl(semid, 0, SETVAL, sem_set) == -1) {
perror("semctl error");
exit(1);
}
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
semaphore_down(semid);
// 子进程访问共享资源
printf("Child process is accessing shared resource.\n");
semaphore_up(semid);
} else {
semaphore_down(semid);
// 父进程访问共享资源
printf("Parent process is accessing shared resource.\n");
semaphore_up(semid);
wait(NULL);
}
if (semctl(semid, 0, IPC_RMID) == -1) {
perror("semctl IPC_RMID error");
}
return 0;
}
在上述代码中，首先通过 ftok 生成一个键值，然后使用 semget 创建一个信号量。父子进程在访问共享资源前先调用 semaphore_down 获取信号量，访问完后调用 semaphore_up 释放信号量，从而避免竞争条件。
僵尸进程与孤儿进程
- 僵尸进程：当子进程结束但父进程没有调用
wait或waitpid来获取子进程的退出状态时，子进程就会变成僵尸进程。僵尸进程虽然已经不再执行，但它的进程控制块（PCB）仍然保留在系统中，占用系统资源。例如，一个父进程创建了多个子进程，每个子进程完成任务后结束，但父进程没有及时等待子进程结束，这些子进程就会成为僵尸进程，随着时间推移，可能会导致系统资源耗尽。 - 解决僵尸进程的方法：父进程可以通过调用
wait或waitpid函数来等待子进程结束并获取其退出状态，从而避免产生僵尸进程。wait函数会阻塞父进程，直到有一个子进程结束；waitpid函数则可以指定等待特定的子进程，并且可以设置非阻塞模式。例如：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main() {
pid_t pid;
pid = fork();
if (pid < 0) {
perror("fork error");
exit(1);
} else if (pid == 0) {
printf("I am the child process. Exiting...\n");
exit(0);
} else {
wait(NULL);
printf("Parent process has waited for the child to finish.\n");
}
return 0;
}
在这个例子中，父进程通过 wait 函数等待子进程结束，从而避免了子进程成为僵尸进程。
3. 孤儿进程：当父进程先于子进程结束时，子进程就会成为孤儿进程。孤儿进程会被 init 进程（PID 为 1）收养，init 进程会负责清理孤儿进程的资源。虽然孤儿进程不会像僵尸进程那样占用过多资源，但在某些情况下，也需要特殊处理。例如，在一个复杂的多进程应用中，可能需要确保孤儿进程能够正确地继续执行其任务，或者进行一些特殊的初始化操作。
多进程程序的调试
- 调试工具：在调试多进程程序时，可以使用一些工具，如
gdb。gdb支持调试多进程程序，可以设置断点、查看变量值等。在使用gdb调试多进程程序时，需要注意如何在不同进程间切换调试上下文。例如，可以使用gdb的attach命令来附加到正在运行的子进程上进行调试。另外，strace工具可以用来跟踪系统调用，这对于分析多进程程序中系统调用的执行情况非常有帮助。例如，通过strace可以查看fork、exec等系统调用的参数和返回值，从而定位程序中的问题。 - 调试技巧：在多进程程序中添加日志输出也是一种有效的调试方法。通过在关键位置输出日志信息，如进程创建、资源访问等，可以了解程序的执行流程和状态。例如，可以使用
printf函数输出进程 ID、函数调用信息等。但要注意在多进程环境下，日志输出可能会因为竞争条件而变得混乱，此时可以使用同步机制（如互斥锁）来保证日志输出的顺序性。另外，在调试时，可以逐步缩小问题范围，例如先创建单个子进程进行调试，确保基本功能正确后再扩展到多个子进程。
实际应用场景中的多进程创建
服务器端编程
- 并发处理客户端请求：在服务器端编程中，多进程常用于并发处理多个客户端的请求。例如，一个网络服务器可能会接收到来自多个客户端的连接请求，通过为每个客户端连接创建一个子进程，可以同时处理多个客户端的请求，提高服务器的并发处理能力。以下是一个简单的基于多进程的网络服务器示例：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#define PORT 8080
#define BACKLOG 10
#define BUFFER_SIZE 1024
void handle_client(int client_socket) {
char buffer[BUFFER_SIZE];
ssize_t bytes_read = recv(client_socket, buffer, BUFFER_SIZE - 1, 0);
if (bytes_read > 0) {
buffer[bytes_read] = '\0';
printf("Received from client: %s\n", buffer);
const char *response = "Hello from server";
send(client_socket, response, strlen(response), 0);
}
close(client_socket);
}
int main() {
int server_socket, client_socket;
struct sockaddr_in server_addr, client_addr;
socklen_t client_addr_len = sizeof(client_addr);
pid_t pid;
server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (server_socket == -1) {
perror("socket error");
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
perror("bind error");
close(server_socket);
exit(1);
}
if (listen(server_socket, BACKLOG) == -1) {
perror("listen error");
close(server_socket);
exit(1);
}
printf("Server is listening on port %d...\n", PORT);
while (1) {
client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_len);
if (client_socket == -1) {
perror("accept error");
continue;
}
pid = fork();
if (pid < 0) {
perror("fork error");
close(client_socket);
} else if (pid == 0) {
close(server_socket);
handle_client(client_socket);
exit(0);
} else {
close(client_socket);
}
}
close(server_socket);
return 0;
}
在上述代码中，服务器监听指定端口，每当有客户端连接时，创建一个子进程来处理该客户端的请求。子进程负责接收客户端数据并发送响应，父进程继续监听新的客户端连接。 2. 任务分发与管理：在一些复杂的服务器应用中，可能需要将不同类型的任务分发给不同的子进程处理。例如，一个文件服务器可能有专门的子进程负责文件读取，另一些子进程负责文件写入，还有子进程负责用户认证等任务。通过合理的任务分发和管理，可以提高服务器的性能和可维护性。例如，可以通过消息队列或者共享内存来实现任务的传递和状态的共享，各个子进程根据任务类型进行相应的处理。
数据处理与并行计算
- 大数据处理：在处理大量数据时，多进程可以将数据分割成多个部分，每个子进程处理一部分数据，最后将结果汇总。例如，在分析一个非常大的日志文件时，可以将日志文件按行或者按大小分割，每个子进程负责处理一部分日志数据，统计特定信息（如某个 IP 地址的访问次数）。最后，父进程收集各个子进程的统计结果并进行汇总，得到最终的分析结果。这样可以大大提高数据处理的速度，充分利用多核 CPU 的性能。
- 并行计算任务：对于一些可以并行化的计算任务，如矩阵运算、数值模拟等，多进程是实现并行计算的一种有效方式。例如，在进行矩阵乘法时，可以将矩阵按行或者按列分割，每个子进程负责计算一部分矩阵元素的乘积，最后将各个子进程的计算结果合并得到最终的乘积矩阵。通过多进程并行计算，可以显著缩短计算时间，提高计算效率。在实现并行计算时，需要注意进程间的同步和数据共享问题，确保计算结果的正确性。
系统监控与管理工具
- 监控系统资源：可以编写一个系统监控工具，通过多进程分别监控不同的系统资源，如 CPU 使用率、内存使用率、磁盘 I/O 等。每个子进程负责监控一种资源，并定期将监控数据发送给父进程。父进程可以将这些数据汇总并进行显示，例如通过命令行界面或者图形界面展示系统资源的实时使用情况。这样可以及时发现系统资源的异常情况，以便进行相应的调整和优化。
- 管理后台服务：在管理多个后台服务时，多进程可以用来启动、停止和监控这些服务。例如，一个系统管理员可能需要管理多个数据库服务、Web 服务器服务等。通过编写一个多进程管理程序，每个子进程负责管理一个服务，如启动、停止服务，检查服务状态等。父进程可以统一协调各个子进程的操作，实现对多个后台服务的集中管理。
通过以上对 Linux C 语言多进程创建流程的详细介绍，包括进程的基本概念、相关系统调用、创建流程、资源管理、常见问题及实际应用场景等方面，希望读者能够对多进程编程有更深入的理解，并能够在实际项目中灵活运用多进程技术解决各种问题。