Linux 多进程编程详解
Linux 多进程编程详解
多进程编程是现代操作系统中一种重要的并发编程技术。通过在同一程序中运行多个独立的进程，可以实现并发处理，充分利用多核处理器的优势，提高程序的运行效率。本文将详细介绍Linux多进程的基本概念、创建方法、进程间通信、同步机制以及实际应用，配以C++示例代码，帮助读者深入理解和掌握多进程编程技术。
1. 多进程的基本概念
在Linux操作系统中，进程是程序的一个实例，是系统进行资源分配和调度的基本单位。每个进程都有独立的地址空间和资源，包括代码段、数据段、堆、栈以及文件描述符等。进程之间通过进程间通信（IPC）机制进行通信和同步。多进程编程就是在同一程序中创建并运行多个进程，以实现并发处理。
1.1 进程的生命周期
进程的生命周期包括以下几个状态：
创建（New）：进程被创建，但尚未准备好执行。 就绪（Ready）：进程已准备好执行，但尚未被分配CPU时间。 运行（Running）：进程正在执行。 阻塞（Blocked）：进程正在等待某些事件（如I/O操作）发生。 终止（Terminated）：进程已完成执行或被终止。
进程的状态转换如下图所示：
+-------------------+
| 创建 (New) |
+-------------------+
|
v
+-------------------+
| 就绪 (Ready) |
+-------------------+
|
v
+-------------------+
| 运行 (Running)|
+-------------------+
|
v
+-------------------+
| 阻塞 (Blocked) |
+-------------------+
|
v
+-------------------+
| 终止 (Terminated)|
+-------------------+进程由操作系统调度，从创建到就绪，再从就绪状态转移到运行状态。如果进程在运行过程中需要等待某些事件（如I/O操作），则会进入阻塞状态。当等待的事件发生时，进程重新进入就绪状态，等待调度运行。当进程完成任务或被终止时，进入终止状态。
1.2 进程控制块（PCB）
进程控制块（PCB，Process Control Block）是操作系统管理进程的主要数据结构，包含了进程的各种信息，包括：
进程标识符（PID）：每个进程都有一个唯一的标识符。
进程状态：表示进程当前的状态（创建、就绪、运行、阻塞、终止）。
程序计数器（PC）：保存进程下一条将要执行的指令地址。
寄存器：保存进程的上下文信息。
内存管理信息：包括进程的地址空间、页表等信息。
I/O状态信息：包括打开的文件描述符、I/O设备等信息。PCB是操作系统进行进程切换和调度的重要依据。
2. 进程的创建
在Linux中，可以通过fork()系统调用创建一个新的进程。fork()会创建一个子进程，该子进程是父进程的副本，继承了父进程的所有资源和上下文。子进程有自己独立的地址空间，父子进程可以并发运行。
2.1 fork()系统调用
fork()系统调用的原型如下：
pid_t fork(void);fork()返回两次，一次在父进程中返回子进程的PID，一次在子进程中返回0。如果fork()失败，则返回-1:
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
int main() {
pid_t pid = fork(); // 创建一个子进程
if (pid < 0) {
// fork失败
std::cerr << "Fork failed!" << std::endl;
return 1;
} else if (pid == 0) {
// 子进程
std::cout << "Hello from Child Process!" << std::endl;
std::cout << "Child Process ID: " << getpid() << std::endl;
std::cout << "Parent Process ID: " << getppid() << std::endl;
} else {
// 父进程
std::cout << "Hello from Parent Process!" << std::endl;
std::cout << "Parent Process ID: " << getpid() << std::endl;
std::cout << "Child Process ID: " << pid << std::endl;
// 等待子进程结束
int status;
waitpid(pid, &status, 0);
if (WIFEXITED(status)) {
std::cout << "Child process exited with status: " << WEXITSTATUS(status) << std::endl;
}
}
return 0;
}在上述代码中，fork()创建了一个子进程。父进程和子进程分别打印各自的PID和相关信息，并通过waitpid()等待子进程结束。
2.2 进程的终止
进程在完成任务后会终止，终止进程可以通过exit()系统调用实现。exit()系统调用的原型如下：
void exit(int status);其中，status是进程的退出状态码，通常为0表示正常退出，非0表示异常退出。
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
int main() {
pid_t pid = fork();
if (pid < 0) {
std::cerr << "Fork failed!" << std::endl;
return 1;
} else if (pid == 0) {
// 子进程
std::cout << "Hello from Child Process!" << std::endl;
std::cout << "Child Process ID: " << getpid() << std::endl;
std::cout << "Parent Process ID: " << getppid() << std::endl;
exit(0); // 子进程正常退出
} else {
// 父进程
std::cout << "Hello from Parent Process!" << std::endl;
std::cout << "Parent Process ID: " << getpid() << std::endl;
std::cout << "Child Process ID: " << pid << std::endl;
// 等待子进程结束
int status;
waitpid(pid, &status, 0);
if (WIFEXITED(status)) {
std::cout << "Child process exited with status: " << WEXITSTATUS(status) << std::endl;
}
}
return 0;
}3. 进程间通信
进程间通信（IPC）是多进程编程中的重要部分，用于在独立的进程之间传递数据和信息。常见的IPC机制包括管道、消息队列、共享内存和信号等。
3.1 管道（Pipe）
管道是一种半双工的通信机制，只能在父子进程或兄弟进程之间使用。管道由两个文件描述符组成，一个用于读端，一个用于写端。使用pipe()系统调用创建管道。
#include <iostream>
#include <unistd.h>
#include <cstring>
int main() {
int fd[2];
if (pipe(fd) == -1) {
std::cerr << "Pipe failed!" << std::endl;
return 1;
}
pid_t pid = fork();
if (pid < 0) {
std::cerr << "Fork failed!" << std::endl;
return 1;
} else if (pid == 0) {
// 子进程
close(fd[0]); // 关闭读端
const char* msg = "Hello from Child Process!";
write(fd[1], msg, strlen(msg) + 1); // 写入管道
close(fd[1]); // 关闭写端
} else {
// 父进程
close(fd[1]); // 关闭写端
char buffer[100];
read(fd[0], buffer, sizeof(buffer)); // 从管道读取
std::cout << "Parent Process received: " << buffer << std::endl;
close(fd[0]); // 关闭读端
}
return 0;
}在上述代码中，父子进程通过管道实现通信。子进程将消息写入管道，父进程从管道读取消息。
3.2 消息队列（Message Queue）
消息队列是一种消息传递机制，允许进程以消息的形式进行通信。消息队列是一个链表，每个消息包含一个消息类型和消息数据。使用msgget()、msgsnd()和msgrcv()系统调用管理消息队列。
#include <iostream>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <cstring>
struct message {
long msg_type;
char msg_text[100];
};
int main() {
key_t key = ftok("progfile", 65); // 生成唯一键
int msgid = msgget(key, 0666 | IPC_CREAT); // 创建消息队列
message msg;
msg.msg_type = 1;
strcpy(msg.msg_text, "Hello from Child Process!");
pid_t pid = fork();
if (pid < 0) {
std::cerr << "Fork failed!" << std::endl;
return 1;
} else if (pid == 0) {
// 子进程，发送消息
msgsnd(msgid, &msg, sizeof(msg.msg_text), 0);
std::cout << "Message sent from Child Process." << std::endl;
} else {
// 父进程，接收消息
msgrcv(msgid, &msg, sizeof(msg.msg_text), 1, 0);
std::cout << "Parent Process received: " << msg.msg_text << std::endl;
// 删除消息队列
msgctl(msgid, IPC_RMID, NULL);
}
return 0;
}在上述代码中，父子进程通过消息队列实现通信。子进程发送消息，父进程接收消息。
共享内存（Shared Memory）
共享内存是一种高效的进程间通信机制，允许多个进程共享一块内存区域。使用 shmget()、shmat() 和 shmdt() 系统调用管理共享内存。
共享内存是所有 IPC 机制中最快的一种，因为进程可以直接访问内存中的数据，而不需要通过内核中介。但是，这也意味着需要额外的同步机制来确保多个进程不会同时修改共享数据而导致数据不一致。
#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <cstring>
int main() {
key_t key = ftok("shmfile", 65); // 生成唯一键
int shmid = shmget(key, 1024, 0666 | IPC_CREAT); // 创建共享内存
pid_t pid = fork();
if (pid < 0) {
std::cerr << "Fork failed!" << std::endl;
return 1;
} else if (pid == 0) {
// 子进程，写入共享内存
char* str = (char*) shmat(shmid腾讯云开发者
