在现代操作系统中，进程就像独立的个体，有时需要相互合作、数据共享，这就要求进程间能够高效通信。本文将为你揭开Linux进程间通信(IPC)的神秘面纱，探讨各种IPC工具的运作原理，同步机制的重要性，以及如何规避潜在风险。我们将通过丰富的C++示例，让你融会贯通IPC实践。
一、IPC概述:进程间畅所欲言
所谓IPC(Inter-Process Communication)，就是指允许进程之间传递数据或进行通信控制的机制。在Linux下，主要的IPC工具包括管道(Pipe)、FIFO、消息队列(Message Queue)、共享内存(Shared Memory)、信号(Signal)等。
IPC工具可以分为两大类:
- 数据传输工具：如管道、消息队列等，用于在进程间传递数据。
-
同步工具：信号量、文件锁等同步工具，则控制对共享资源的访问顺序，避免竞争条件。
二、选择恰当的IPC工具
1、数据传输工具
从上面的分类中我们可以看到，IPC 工具有很多，而区分这些工具的关键因素就是数据读取和写入的形式。
比如说，一些 IPC 工具要求在写数据时将数据从用户内存传输至内核内存，读取数据时则将数据从内核内存输入到用户内存。
其中最典型的就是流 式 socket 和管道。
（1）、流 式 socket
流式 socket 数据必须从用户缓冲区写入至 TCP 连接的发送缓冲区中 ，读取数据时则从 TCP 连接的接收缓冲区进行读取。
流式socket通常指的是面向连接的TCP socket，数据的发送和接收通过socket描述符来进行。
以下是一个简单的示例，演示如何使用TCP socket进行数据的发送和接收：
#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
int main() {
const int server_port = 8080;
const char* server_ip = "127.0.0.1";
int sock_fd;
struct sockaddr_in server_addr;
// 创建socket
sock_fd = socket(AF_INET, SOCK_STREAM, 0);
if (sock_fd < 0) {
std::cerr << "Failed to create socket" << std::endl;
return 1;
}
// 设置服务器地址
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(server_port);
if (inet_pton(AF_INET, server_ip, &server_addr.sin_addr) <= 0) {
std::cerr << "Invalid address" << std::endl;
close(sock_fd);
return 1;
}
// 连接到服务器
if (connect(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
std::cerr << "Failed to connect to the server" << std::endl;
close(sock_fd);
return 1;
}
// 发送数据
const char* message = "Hello, Server!";
if (send(sock_fd, message, strlen(message), 0) < 0) {
std::cerr << "Send failed" << std::endl;
close(sock_fd);
return 1;
}
std::cout << "Message sent" << std::endl;
// 接收数据
char buffer[1024] = {0};
ssize_t bytes_received = recv(sock_fd, buffer, sizeof(buffer) - 1, 0);
if (bytes_received < 0) {
std::cerr << "Receive failed" << std::endl;
close(sock_fd);
return 1;
}
std::cout << "Message received: " << buffer << std::endl;
// 关闭socket
close(sock_fd);
return 0;
}
在这个示例中，我们首先创建了一个TCP socket，然后设置了服务器的地址和端口，并尝试连接到服务器。一旦连接成功，我们使用send函数将一个字符串消息发送到服务器，消息数据从用户缓冲区（在这个例子中是message字符串）写入到TCP连接的发送缓冲区中。
接收数据时，我们使用recv函数从TCP连接的接收缓冲区读取数据到用户缓冲区（buffer数组）。如果recv函数成功，它返回接收到的字节数，我们将其打印出来。
最后，我们使用close函数关闭socket。
请注意，这个示例是一个阻塞的socket操作，send和recv函数在数据发送或接收完成之前会阻塞。在实际的网络编程中，你可能需要处理更多的错误情况，并可能需要使用非阻塞socket或信号驱动I/O等技术来提高程序的响应性和性能。
（2）、管道
在Linux中，管道（pipe）是一种进程间通信（IPC）机制，允许一个进程（生产者）与另一个进程（消费者）通过一个缓冲区交换数据。管道是单向的，数据只能在一个方向上流动，并且通常用于父子进程或者兄弟进程之间的通信。
以下是演示管道通信的基本流程：
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <cerrno>
#include <cstring>
int main() {
int pipefds[2];
pid_t pid;
const char *message = "Hello, this is the message going through the pipe!";
char readbuffer[128];
// 创建管道
if (pipe(pipefds) == -1) {
std::cerr << "Pipe failed: " << strerror(errno) << std::endl;
return 1;
}
// 创建子进程
pid = fork();
if (pid == -1) {
std::cerr << "Fork failed" << std::endl;
close(pipefds[0]); // 读取端
close(pipefds[1]); // 写入端
return 1;
}
if (pid > 0) {
// 父进程，关闭读取端，使用写入端
close(pipefds[0]);
// 写数据到管道
if (write(pipefds[1], message, strlen(message)) == -1) {
std::cerr << "Write to pipe failed: " << strerror(errno) << std::endl;
}
close(pipefds[1]); // 关闭写入端
// 等待子进程结束
wait(NULL);
} else {
// 子进程，关闭写入端，使用读取端
close(pipefds[1]);
// 从管道读取数据
if (read(pipefds[0], readbuffer, sizeof(readbuffer)) == -1) {
std::cerr << "Read from pipe failed: " << strerror(errno) << std::endl;
}
readbuffer[strcspn(readbuffer, "\n")] = 0; // 去除换行符
std::cout << "Message received through pipe: " << readbuffer << std::endl;
close(pipefds[0]); // 关闭读取端
}
return 0;
}
在这个示例中，我们首先使用pipe系统调用创建了一个管道，并获取了两个文件描述符：pipefds[0]（用于读取）和pipefds[1]（用于写入）。
然后，我们使用fork创建了一个子进程。
在父进程中，我们关闭了读取端（pipefds[0]），并通过写入端发送了一个字符串消息到管道。
在子进程中，我们关闭了写入端（pipefds[1]），并从读取端读取了管道中的数据。
请注意，管道的缓冲区大小通常是有限的，Linux中默认的管道缓冲区大小为65536字节。如果生产者写入的数据超过了缓冲区的大小，写入操作将会阻塞，直到消费者读取了足够的数据，释放了缓冲区空间。
此外，由于管道是单向的，所以通常需要两个管道来进行双向通信：一个用于从父进程到子进程的通信，另一个用于从子进程到父进程的通信。而且，管道是半双工的，意味着在任何给定时间，只能进行一个方向的通信。
（3）、FIFO
FIFO（也称为命名管道或具名管道）提供了一种在不相关的进程之间进行通信的方式，与管道类似，但具有文件系统中的名称。这意味着任何进程都可以通过FIFO的路径名来打开它，进行读写操作。
以下演示FIFO通信的基本流程：
#include <iostream>
#include <fcntl.h> // 包含 open 函数
#include <unistd.h> // 包含 read, write 函数
#include <sys/stat.h>// 包含 S_IRUSR, S_IWUSR, S_IRGRP, S_IWGRP, S_IROTH, S_IWOTH
#include <cstring>
// 创建FIFO
bool create_fifo(const char* fifo_name) {
// 使用mkfifo创建FIFO
if (mkfifo(fifo_name, 0666) == -1) { // 0666 表示读写权限给所有用户
std::cerr << "Failed to create FIFO: " << strerror(errno) << std::endl;
return false;
}
return true;
}
// 写入FIFO
bool write_fifo(const char* fifo_name, const char* message) {
int fd = open(fifo_name, O_WRONLY);
if (fd == -1) {
std::cerr << "Failed to open FIFO for writing: " << strerror(errno) << std::endl;
return false;
}
if (write(fd, message, strlen(message)) == -1) {
std::cerr << "Failed to write to FIFO: " << strerror(errno) << std::endl;
close(fd);
return false;
}
close(fd);
return true;
}
// 从FIFO读取
bool read_fifo(const char* fifo_name) {
int fd = open(fifo_name, O_RDONLY);
if (fd == -1) {
std::cerr << "Failed to open FIFO for reading: " << strerror(errno) << std::endl;
return false;
}
char buffer[1024];
ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
if (bytes_read == -1) {
std::cerr << "Failed to read from FIFO: " << strerror(errno) << std::endl;
close(fd);
return false;
}
buffer[bytes_read] = '\0'; // 确保字符串以null结尾
std::cout << "Message received from FIFO: " << buffer << std::endl;
close(fd);
return true;
}
int main() {
const char* fifo_name = "/tmp/my_fifo";
// 创建FIFO
if (!create_fifo(fifo_name)) {
return 1;
}
// 写入FIFO
if (!write_fifo(fifo_name, "Hello, this is the message going through the FIFO!")) {
return 1;
}
// 读取FIFO
if (!read_fifo(fifo_name)) {
return 1;
}
// 可以选择删除FIFO
// unlink(fifo_name);
return 0;
}
在这个示例中，我们首先定义了三个函数：
create_fifo：创建一个FIFO。write_fifo：向FIFO写入数据。read_fifo：从FIFO读取数据。
在main函数中，我们首先创建了一个FIFO，然后向其写入了一条消息，最后从FIFO中读取消息并打印出来。
请注意，FIFO是一个阻塞设备，如果打开FIFO进行读取但没有进程写入数据，读取操作将阻塞。同样，如果打开FIFO进行写入但没有进程读取数据，写入操作也将阻塞。为了处理这种情况，通常需要使用非阻塞打开或配合使用信号和多路复用技术（如select或poll）。
此外，FIFO的权限可以通过mkfifo的第二个参数来设置，类似于文件的权限设置。在上面的示例中，我们使用了0666，这表示FIFO对所有用户都是可读可写的。在实际应用中，应根据需要设置适当的权限。
（4）、其他数据传输工具-消息队列和udp
消息队列和UDP（用户数据报协议）是两种不同的进程间通信（IPC）和网络通信机制。它们都通过将数据写入内核来进行操作，但是它们在数据传输的方式和特性上有所不同。
- 消息队列
消息队列是UNIX系统提供的一种IPC机制，允许进程发送和接收消息。消息队列通过key来标识，进程可以通过这个key来发送和接收消息。
以下是消息队列的演示：
#include <iostream>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <cstring>
// 消息结构体
struct msgbuf {
long mtype;
char mtext[256];
};
int main() {
key_t key = ftok("some_file", 'a'); // 创建唯一的key
if (key == -1) {
perror("ftok");
return 1;
}
int msgid = msgget(key, 0666 | IPC_CREAT); // 创建消息队列
if (msgid == -1) {
perror("msgget");
return 1;
}
// 初始化消息
msgbuf msg;
msg.mtype = 1;
strcpy(msg.mtext, "Hello, this is a message in the queue!");
// 发送消息
if (msgsnd(msgid, &msg, sizeof(msg.mtext), 0) == -1) {
perror("msgsnd");
msgctl(msgid, IPC_RMID, NULL);
return 1;
}
// 接收消息
msgrcv(msgid, &msg, sizeof(msg.mtext), msg.mtype, 0);
std::cout << "Received message: " << msg.mtext << std::endl;
// 删除消息队列
if (msgctl(msgid, IPC_RMID, NULL) == -1) {
perror("msgctl");
return 1;
}
return 0;
}
在上面的示例中，我们首先使用ftok函数创建一个唯一的key，然后使用msgget函数创建或获取一个消息队列。我们定义了一个msgbuf结构体来存储消息的类型和内容。然后，我们使用msgsnd函数发送消息，使用msgrcv函数接收消息。最后，我们使用msgctl函数删除消息队列。
- UDP套接字
UDP是一种无连接的网络通信协议，它允许应用程序发送和接收数据报（datagrams）。UDP不保证数据报的顺序、完整性或可靠性，因此它通常用于那些可以容忍一定丢包率的应用，如视频会议或在线游戏。
以下代码演示UDP通信：
#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main() {
int sockfd;
struct sockaddr_in server_addr, client_addr;
const char *message = "Hello, this is a UDP datagram!";
char buffer[1024];
// 创建UDP socket
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("socket");
return 1;
}
// 设置服务器地址
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080);
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
// 发送数据
if (sendto(sockfd, message, strlen(message), 0,
(struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("sendto");
close(sockfd);
return 1;
}
std::cout << "UDP datagram sent" << std::endl;
// 接收数据
socklen_t len = sizeof(client_addr);
ssize_t bytes_received = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,
(struct sockaddr*)&client_addr, &len);
if (bytes_received < 0) {
perror("recvfrom");
close(sockfd);
return 1;
}
buffer[bytes_received] = '\0'; // 确保字符串以null结尾
std::cout << "UDP datagram received: " << buffer << std::endl;
// 关闭socket
close(sockfd);
return 0;
}
在这个示例中，我们首先使用socket函数创建了一个UDP socket。然后，我们设置了服务器的地址和端口，并使用sendto函数发送了一个数据报。我们使用recvfrom函数接收了数据报，并打印了接收到的数据。最后，我们关闭了socket。
请注意，UDP是面向数据报的，每次发送和接收操作都是独立的，没有顺序或连接的概念。因此，每次写入和读取都是完整的一条消息，不能使用字节流的方式进行写入。
2、共享内存
共享内存是一种高效的进程间通信（IPC）机制，它允许两个或多个进程共享一个给定的存储区。由于共享内存允许进程直接访问同一块内存，因此它比管道、消息队列或套接字等其他IPC机制具有更高的性能。但是，共享内存需要适当的同步机制来避免竞态条件和数据不一致的问题。
以下是一个简单的示例，演示了如何使用共享内存和信号量来实现进程间的同步：
#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <cstring>
int main() {
key_t key = ftok("some_file", 'a');
if (key == -1) {
perror("ftok");
return 1;
}
// 创建共享内存段
int shm_id = shmget(key, sizeof(int), IPC_CREAT | 0666);
if (shm_id < 0) {
perror("shmget");
return 1;
}
// 附加共享内存
int *shared_mem = (int *)shmat(shm_id, NULL, 0);
if (shared_mem == (void *)-1) {
perror("shmat");
return 1;
}
// 创建信号量
int sem_id = semget(key, 1, IPC_CREAT | 0666);
if (sem_id < 0) {
perror("semget");
return 1;
}
// 设置信号量的值
if (semctl(sem_id, 0, SETVAL, 1) == -1) { // 初始值设为1
perror("semctl SETVAL");
return 1;
}
// 写入共享内存的进程
*shared_mem = 42; // 写入数据
// 等待信号量
struct sembuf p_op = {sem_id, 0, -1};
semop(sem_id, &p_op, 1);
// 执行其他任务...
// 通知信号量
struct sembuf v_op = {sem_id, 0, 1};
semop(sem_id, &v_op, 1);
// 从共享内存分离
if (shmdt(shared_mem) == -1) {
perror("shmdt");
return 1;
}
// 删除共享内存和信号量
if (shmctl(shm_id, IPC_RMID, NULL) == -1) {
perror("shmctl IPC_RMID");
return 1;
}
if (semctl(sem_id, 0, IPC_RMID) == -1) {
perror("semctl IPC_RMID");
return 1;
}
return 0;
}
在这个示例中，我们首先使用ftok函数创建一个唯一的key，然后使用shmget函数创建一个共享内存段。我们使用shmat函数将共享内存附加到当前进程的地址空间，并将其映射到一个int指针上。
接着，我们使用semget函数创建一个信号量集，并使用semctl函数将其初始值设置为1。我们定义了两个信号量操作：p_op用于等待（P操作），v_op用于通知（V操作）。
在写入共享内存之前，我们执行了P操作，这会等待信号量的值为正。写入完成后，我们执行了V操作，这会增加信号量的值，允许其他进程访问共享内存。
最后，我们使用shmdt函数从共享内存分离，使用shmctl和semctl函数分别删除共享内存段和信号量集。
请注意，这个示例仅演示了单个进程中共享内存和信号量的使用。在实际的多进程环境中，你需要创建多个进程，并在它们之间同步对共享内存的访问。通常，这是通过在父进程中创建共享内存和信号量，然后在子进程中附加共享内存和操作信号量来实现的。
三、同步机制:规避惊心动魄
1、信号量
信号量（Semaphore）是一种同步机制，用于控制多个进程或线程对共享资源的访问。本质上就是内核维护的一个整数，其值永远不会小于 0。如果 一个进程试图将信号量的值减少至小于 0，那么内核会阻塞该操作，直到信号量增长到允许执行该操作的程度。
通常我们会使用一个二元信号量，也就是信号量的值要么是 0，要么是 1。此时非常类似于 mutex，mutex 的状态要么是已上锁，要么是未上锁 。
在C++中，可以使用 POSIX 线程库（pthread）提供的信号量功能。以下是使用二元信号量（也称为互斥锁，mutex）的一个简单示例：
#include <iostream>
#include <pthread.h>
#include <semaphore.h>
// 创建一个信号量对象
sem_t sem;
// 线程函数，尝试对共享资源进行操作
void* thread_function(void* arg) {
// 等待（P操作）信号量，直到信号量的值大于0
sem_wait(&sem);
// 临界区开始
std::cout << "Thread " << std::this_thread::get_id()
<< " is in the critical section." << std::endl;
// ... 执行对共享资源的操作 ...
// 临界区结束
// 通知（V操作）信号量，增加其值
sem_post(&sem);
return nullptr;
}
int main() {
// 初始化信号量，设置其值为1
sem_init(&sem, 0, 1);
// 创建线程
pthread_t t1, t2;
pthread_create(&t1, NULL, thread_function, NULL);
pthread_create(&t2, NULL, thread_function, NULL);
// 等待线程结束
pthread_join(t1, NULL);
pthread_join(t2, NULL);
// 销毁信号量
sem_destroy(&sem);
return 0;
}
在这个示例中，我们首先使用sem_init函数初始化了一个信号量sem，其初始值为1。然后创建了两个线程t1和t2，它们都尝试执行thread_function函数。
在thread_function函数中，我们首先调用sem_wait函数来执行P操作，这会阻塞线程直到信号量的值大于0。一旦信号量的值大于0，sem_wait函数会减少信号量的值，然后线程可以进入临界区。在临界区内，线程可以安全地访问共享资源。
当线程完成对共享资源的访问后，它会调用sem_post函数来执行V操作，这会增加信号量的值，允许其他等待的线程进入临界区。
最后，在main函数中，我们等待所有线程结束，然后使用sem_destroy函数销毁信号量。
请注意，这个示例演示了如何使用信号量来同步两个线程对共享资源的访问。在实际应用中，信号量可以用于更复杂的同步场景，包括跨进程同步。此外，使用信号量时需要小心，以避免死锁和其他同步问题。
2、文件锁
文件锁是一种用于进程间同步的机制，它通过锁定文件的特定部分来实现。在UNIX和类UNIX系统中，文件锁通常通过fcntl函数来管理。
文件锁分为两种类型：
-
读锁（共享锁）：允许多个进程读取文件，但不能写入。
-
写锁（互斥锁）：只允许一个进程写入文件，其他进程不能读取也不能写入。
文件锁是自动释放的，当进程终止或完成对文件的访问时，内核会自动移除锁。
以下是使用C++演示文件锁的基本流程：
#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
int main() {
const char* filename = "example.txt";
// 创建或打开文件
int fd = open(filename, O_RDWR | O_CREAT, 0666);
if (fd == -1) {
perror("open");
return 1;
}
// 锁定文件
struct flock lock;
memset(&lock, 0, sizeof(lock));
lock.l_type = F_WRLCK; // 请求写锁
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0; // 0表示锁定整个文件
// 使用fcntl尝试锁定文件
if (fcntl(fd, F_SETLKW, &lock) == -1) {
perror("fcntl F_SETLKW");
close(fd);
return 1;
}
// 临界区开始：文件已被锁定，可以安全写入
std::cout << "File is locked for writing." << std::endl;
// 执行写操作...
// write(fd, "data", 4);
// 临界区结束：解锁文件
lock.l_type = F_UNLCK; // 请求解锁
if (fcntl(fd, F_SETLK, &lock) == -1) {
perror("fcntl F_SETLK");
}
close(fd); // 关闭文件描述符
return 0;
}
在上述代码中，我们首先使用open函数打开或创建一个文件，并获取文件描述符fd。然后，我们设置了struct flock结构体来定义锁的参数，包括锁的类型（读锁或写锁）、起始位置、长度等。
我们使用fcntl函数与F_SETLKW命令来请求锁。F_SETLKW命令会阻塞调用进程，直到锁被成功设置。一旦获得锁，我们就可以安全地执行文件的写入操作。
完成操作后，我们将锁的类型设置为F_UNLCK，再次使用fcntl函数与F_SETLK命令来释放锁。
请注意，文件锁的行为可能会受到操作系统和文件系统的影响。在某些系统中，文件锁可能不是强制性的，这意味着其他进程可能能够忽略这些锁。在使用文件锁时，务必要确保正确地请求和释放锁，以避免死锁或资源泄露。
3、信号 (Signal)
我们还可以利用信号(Signal)在进程间传递消息，比如父进程通过信号通知子进程其已退出。不过，信号应用于IPC的情况并不常见，主要有以下两方面原因:
- 信号遵循可靠传递原则，不会排队，可能会丢失;
- 信号携带的信息量有限，不太适合传输大量数据。
因此，信号更多被用作进程间的"小纸条"，告知对方发生了某些事件，具体数据传输还需要借助其他IPC工具。
需要详细了解信号 相关知识的通讯，请查阅往期文章：
- Linux信号大揭秘-从中断到控制进程，一步步掌握进程通信利器!
- linux信号集与信号掩码-保护信号处理程序，确保进程正确运行
- linux进程家族-管理子进程，确保进程族稳健运行
四、结语
总的来说，选择IPC工具时需要考虑通信双方、数据量、同步需求等多方面因素，合理权衡就能找到最佳选择。这个领域学习曲线平缓，但内功修炼到极致，却又别有一番天地。你是否已跃跃欲试，迫不及待想投身到IPC的海洋中?本文仅作了简单探讨，若想彻底掌握该领域的精髓，不妨持续关注我们的后续分享。
![python的line[:-1]和line[-1]](https://img-blog.csdnimg.cn/direct/0cd795e076f745f4b34a63462fbf9da9.png)
