C++ Linux系统中如何管理进程间通信

在Linux系统中，C++可以通过多种方式实现进程间通信（IPC）。以下是一些常用的IPC机制：

1. 管道（Pipes）:

   • 匿名管道（Anonymous Pipes）：通常用于具有亲缘关系的进程间通信，如父子进程。
   • 命名管道（Named Pipes，FIFOs）：允许无亲缘关系的进程间通信。

2. 信号（Signals）:

   • 用于通知接收进程某个事件已经发生。

3. 消息队列（Message Queues）:

   • 允许进程发送和接收消息队列中的消息。

4. 共享内存（Shared Memory）:

   • 多个进程可以映射同一段物理内存，实现高效的数据交换。

5. 信号量（Semaphores）:

   • 用于进程同步，控制多个进程对共享资源的访问。

6. 套接字（Sockets）:

   • 可用于不同机器间的进程通信，也适用于同一台机器上的进程。

7. 内存映射文件（Memory-mapped Files）:

   • 将文件或设备映射到进程的地址空间，实现文件数据和共享内存之间的通信。

下面是使用这些IPC机制的一些基本示例：

匿名管道

#include <
    unistd.h>
    
#include <
    iostream>


int main() {
    
    int pipefd[2];
    
    pid_t pid;
    
    char buffer[256];


    // 创建匿名管道
    if (pipe(pipefd) == -1) {
    
        perror("pipe");
    
        exit(EXIT_FAILURE);

    }
    

    // 创建子进程
    pid = fork();

    if (pid == -1) {
    
        perror("fork");
    
        exit(EXIT_FAILURE);

    }
    

    if (pid >
 0) {
     // 父进程
        close(pipefd[0]);
     // 关闭读端
        const char* message = "Hello from parent!";
    
        write(pipefd[1], message, strlen(message) + 1);
     // 写入数据
        close(pipefd[1]);
 // 关闭写端
    }
 else {
     // 子进程
        close(pipefd[1]);
     // 关闭写端
        read(pipefd[0], buffer, sizeof(buffer));
     // 读取数据
        std::cout <
    <
     "Child received: " <
    <
     buffer <
    <
     std::endl;
    
        close(pipefd[0]);
 // 关闭读端
    }
    

    return 0;

}
    

命名管道（FIFO）

#include <
    sys/stat.h>
    
#include <
    fcntl.h>
    
#include <
    unistd.h>
    
#include <
    iostream>


int main() {
    
    const char* fifo = "/tmp/myfifo";
    
    mkfifo(fifo, 0666);
    

    int fd = open(fifo, O_RDWR);

    if (fd == -1) {
    
        perror("open");
    
        exit(EXIT_FAILURE);

    }
    

    const char* message = "Hello from FIFO!";
    
    write(fd, message, strlen(message) + 1);
    

    char buffer[256];
    
    read(fd, buffer, sizeof(buffer));
    
    std::cout <
    <
     "Received: " <
    <
     buffer <
    <
     std::endl;
    

    close(fd);
    
    unlink(fifo);
     // 删除FIFO

    return 0;

}
    

共享内存

#include <
    sys/ipc.h>
    
#include <
    sys/shm.h>
    
#include <
    iostream>
    
#include <
    cstring>


int main() {
    
    key_t key = ftok("shmfile", 65);
    
    int shmid = shmget(key, 1024, 0666|IPC_CREAT);
    
    char *str = (char*) shmat(shmid, (void*)0, 0);
    

    strcpy(str, "Hello shared memory!");
    
    std::cout <
    <
     "Shared memory: " <
    <
     str <
    <
     std::endl;
    

    shmdt(str);
    
    shmctl(shmid, IPC_RMID, NULL);
    

    return 0;

}
    

信号量

#include <
    sys/ipc.h>
    
#include <
    sys/sem.h>
    
#include <
    iostream>


union semun {
    
    int val;
    
    struct semid_ds *buf;
    
    unsigned short *array;

}
    ;


int main() {
    
    key_t key = ftok("semfile", 65);
    
    int semid = semget(key, 1, 0666|IPC_CREAT);
    

    union semun arg;
    
    arg.val = 1;
     // 初始化信号量为1
    semctl(semid, 0, SETVAL, arg);


    // 使用semop进行P操作（等待信号量）
    struct sembuf sb = {
0, -1, SEM_UNDO}
    ;
    
    semop(semid, &
    sb, 1);
    

    std::cout <
    <
     "Semaphore value decreased to 0, performing operation..." <
    <
     std::endl;
    

    // 使用semop进行V操作（释放信号量）
    sb.sem_op = 1;
    
    semop(semid, &
    sb, 1);
    

    semctl(semid, 0, IPC_RMID);
    

    return 0;

}
    

套接字

// 这里只给出服务器端的简单示例，客户端需要另外编写
#include <
    sys/socket.h>
    
#include <
    netinet/in.h>
    
#include <
    arpa/inet.h>
    
#include <
    unistd.h>
    
#include <
    iostream>


int main() {
    
    int server_fd, new_socket;
    
    struct sockaddr_in address;
    
    int opt = 1;
    
    int addrlen = sizeof(address);

    char buffer[1024] = {
0}
    ;


    // 创建socket文件描述符
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    
        perror("socket failed");
    
        exit(EXIT_FAILURE);

    }
    

    // 绑定socket到端口
    address.sin_family = AF_INET;
    
    address.sin_addr.s_addr = INADDR_ANY;
    
    address.sin_port = htons(8080);
    

    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &
opt, sizeof(opt))) {
    
        perror("setsockopt");
    
        exit(EXIT_FAILURE);

    }
    

    if (bind(server_fd, (struct sockaddr *)&
    address, sizeof(address)) <
 0) {
    
        perror("bind failed");
    
        exit(EXIT_FAILURE);

    }
    

    // 监听连接
    if (listen(server_fd, 3) <
 0) {
    
        perror("listen");
    
        exit(EXIT_FAILURE);

    }
    

    // 接受连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&
    address, (socklen_t*)&
    addrlen)) <
 0) {
    
        perror("accept");
    
        exit(EXIT_FAILURE);

    }
    

    // 读取数据
    read(new_socket, buffer, 1024);
    
    std::cout <
    <
     "Message from client: " <
    <
     buffer <
    <
     std::endl;
    

    // 发送响应
    send(new_socket, "Hello from server", 17, 0);
    
    std::cout <
    <
     "Hello message sent\n";
    

    close(new_socket);
    
    close(server_fd);
    

    return 0;

}
    

这些示例展示了如何在C++中使用Linux IPC机制。在实际应用中，你需要根据具体需求选择合适的IPC方法，并处理好同步和互斥的问题。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！