在Linux环境下使用C++进行多进程编程时，可以采用多种技术和模式。以下是一些常用的技巧和最佳实践：
fork() 创建子进程fork() 是创建新进程的最基本方法。它会复制调用它的进程（父进程）的地址空间给新进程（子进程）。
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>
int main() {
pid_t pid = fork();
if (pid == -1) {
// 错误处理
perror("fork failed");
return 1;
} else if (pid == 0) {
// 子进程
std::cout << "Child process, PID: " << getpid() << std::endl;
} else {
// 父进程
int status;
waitpid(pid, &status, 0); // 等待子进程结束
std::cout << "Parent process, child PID: " << pid << std::endl;
}
return 0;
}
pipe() 进行进程间通信pipe() 可以用来创建一个管道，实现父子进程之间的单向通信。
#include <unistd.h>
#include <iostream>
int main() {
int pipefd[2];
if (pipe(pipefd) == -1) {
perror("pipe failed");
return 1;
}
pid_t pid = fork();
if (pid == -1) {
perror("fork failed");
return 1;
} else if (pid == 0) {
// 子进程
close(pipefd[0]); // 关闭不需要的读端
write(pipefd[1], "Hello from child", 17);
close(pipefd[1]);
} else {
// 父进程
close(pipefd[1]); // 关闭不需要的写端
char buffer[20];
read(pipefd[0], buffer, 17);
std::cout << "Parent received: " << buffer << std::endl;
close(pipefd[0]);
}
return 0;
}
fork() 和 exec() 组合exec() 系列函数可以用来替换子进程的地址空间，执行新的程序。
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>
int main() {
pid_t pid = fork();
if (pid == -1) {
perror("fork failed");
return 1;
} else if (pid == 0) {
// 子进程
execl("/bin/ls", "ls", "-l", NULL);
perror("execl failed"); // 如果execl成功，这行不会执行
return 1;
} else {
// 父进程
int status;
waitpid(pid, &status, 0); // 等待子进程结束
std::cout << "Child process finished" << std::endl;
}
return 0;
}
wait() 和 waitpid() 等待子进程wait() 和 waitpid() 可以用来等待子进程结束，避免产生僵尸进程。
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>
int main() {
pid_t pid = fork();
if (pid == -1) {
perror("fork failed");
return 1;
} else if (pid == 0) {
// 子进程
std::cout << "Child process, PID: " << getpid() << std::endl;
return 42; // 子进程退出码
} else {
// 父进程
int status;
pid_t result = waitpid(pid, &status, 0);
if (result == -1) {
perror("waitpid failed");
return 1;
}
if (WIFEXITED(status)) {
std::cout << "Child exited with status: " << WEXITSTATUS(status) << std::endl;
}
}
return 0;
}
pthread 进行多线程编程虽然这不是多进程编程，但在某些情况下，使用多线程可能比多进程更高效。pthread 库提供了创建和管理线程的接口。
#include <pthread.h>
#include <iostream>
void* thread_function(void* arg) {
std::cout << "Thread running, ID: " << pthread_self() << std::endl;
return NULL;
}
int main() {
pthread_t thread;
if (pthread_create(&thread, NULL, thread_function, NULL) != 0) {
perror("pthread_create failed");
return 1;
}
pthread_join(thread, NULL);
std::cout << "Thread finished" << std::endl;
return 0;
}
posix_spawn() 创建进程posix_spawn() 是一个更现代的创建进程的接口，比 fork() 和 exec() 组合更高效。
#include <spawn.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
posix_spawn_file_actions_t actions;
posix_spawn_file_actions_init(&actions);
char *argv[] = {"ls", "-l", NULL};
pid_t pid;
int status = posix_spawn(&pid, argv[0], &actions, NULL, argv, environ);
if (status != 0) {
fprintf(stderr, "posix_spawn failed\n");
return 1;
}
int child_status;
waitpid(pid, &child_status, 0);
if (WIFEXITED(child_status)) {
printf("Child exited with status %d\n", WEXITSTATUS(child_status));
}
posix_spawn_file_actions_destroy(&actions);
return 0;
}
shared memory 和 semaphores 进行进程间同步和通信共享内存和信号量可以用来实现更复杂的进程间通信和同步。
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <iostream>
// 共享内存和信号量的初始化和使用代码省略
message queues 进行进程间通信消息队列提供了一种异步的进程间通信机制。
#include <mqueue.h>
#include <iostream>
#include <cstring>
// 消息队列的初始化和使用代码省略
sockets 进行进程间通信套接字可以用来实现跨网络的进程间通信。
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <iostream>
// 套接字的初始化和使用代码省略
在多进程编程中，错误处理和资源管理尤为重要。确保在适当的时候关闭文件描述符、释放共享内存等资源，并处理可能的错误情况。
通过结合这些技巧，可以在Linux环境下高效地进行C++多进程编程。
