超详细进程间通信

已于 2024-07-30 11:44:34 修改
阅读量628 收藏 11
点赞数 6
分类专栏： C++学习 文章标签： 服务器 网络 linux
于 2024-07-30 11:43:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lemon_D1999/article/details/140792211
版权

进程间通信（Inter-Process Communication, IPC）是指不同进程之间进行数据交换和同步的机制。常见的进程间通信方法包括：  下方有附代码示例

  1. 管道（Pipe）：

    • 无名管道（Unnamed Pipe）：在父子进程或者兄弟进程之间传递数据，是一种单向通信方式。
    • 命名管道（Named Pipe 或 FIFO）：允许无亲缘关系进程之间进行通信，也是一种单向通信方式。

  2. 信号（Signal）：

    • 通过发送信号来通知接收进程执行某种操作，如终止进程、中断等。

  3. 消息队列（Message Queue）：

    • 允许一个进程向另一个进程发送消息的数据结构。消息队列是一种可以在不同进程之间通信的方式，通过系统调用来实现。

  4. 共享内存（Shared Memory）：

    • 允许多个进程访问同一块物理内存区域，进程可以直接读写这块内存，是一种高效的 IPC 方法。共享内存是最快的方式

  5. 信号量（Semaphores）：

    • 用于进程间同步的一种机制，可以用来保护共享资源，避免竞态条件。

  6. 套接字（Socket）：

    • 套接字是一种网络编程中常见的通信机制，也可以用于不同主机或同一主机的不同进程之间的通信。

  7. 文件（File）：

    • 通过文件系统中的文件进行数据交换，可以结合文件锁定（File Locking）来实现进程间同步。

  8. 信号量（Semaphore）：

    • 用于控制多个进程对共享资源的访问，保证资源不被同时访问和破坏。

每种方法都有其适用的场景和特点，选择合适的进程间通信方法取决于应用程序的需求和设计。

C++代码示例 

1. 管道（Pipe）

管道是单向通信，只能一边写、另一边读，要反向需要创建新管道

无名管道（Unnamed Pipe）
#include <unistd.h>
#include <iostream>

int main() {
    int pipefds[2];
    char buffer[30];

    // 创建管道
    if (pipe(pipefds) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        close(pipefds[1]); // 关闭写端
        read(pipefds[0], buffer, sizeof(buffer));
        std::cout << "Child read: " << buffer << std::endl;
        close(pipefds[0]);
    } else { // 父进程
        close(pipefds[0]); // 关闭读端
        write(pipefds[1], "Hello from parent", 18);
        close(pipefds[1]);
    }

    return 0;
}

命名管道（FIFO）

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

#define FIFO_FILE "myfifo"

int main() {
    mkfifo(FIFO_FILE, 0666);

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        int fd = open(FIFO_FILE, O_RDONLY);
        char buffer[100];
        read(fd, buffer, sizeof(buffer));
        std::cout << "Child read: " << buffer << std::endl;
        close(fd);
    } else { // 父进程
        int fd = open(FIFO_FILE, O_WRONLY);
        write(fd, "Hello from parent", 18);
        close(fd);
    }

    unlink(FIFO_FILE);
    return 0;
}

2. 信号（Signal）

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

//信号处理函数
void signal_handler(int signum) {
    std::cout << "Received signal: " << signum << std::endl;
}

int main() {
    signal(SIGUSR1, signal_handler);

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        sleep(1);
        kill(getppid(), SIGUSR1);    //kill不是杀死进程、kill在此用于发送信号
    } else { // 父进程
        pause(); // 等待信号
    }

    return 0;
}

3. 消息队列（Message Queue）

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

struct msg_buffer {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key = ftok("progfile", 65);
    int msgid = msgget(key, 0666 | IPC_CREAT);
    msg_buffer message;

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        msgrcv(msgid, &message, sizeof(message), 1, 0);
        std::cout << "Child received: " << message.msg_text << std::endl;
    } else { // 父进程
        message.msg_type = 1;
        strcpy(message.msg_text, "Hello from parent");
        msgsnd(msgid, &message, sizeof(message), 0);
        wait(NULL);
        msgctl(msgid, IPC_RMID, NULL);
    }

    return 0;
}

 4. 共享内存（Shared Memory）

#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#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);

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        sleep(1); // 确保父进程先写入
        std::cout << "Child read: " << str << std::endl;
        shmdt(str);
    } else { // 父进程
        strcpy(str, "Hello from parent");
        shmdt(str);
        wait(NULL);
        shmctl(shmid, IPC_RMID, NULL);
    }

    return 0;
}

5. 信号量（Semaphore）

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

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

    semctl(semid, 0, SETVAL, 1); // 初始化信号量

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        struct sembuf sb = {0, -1, 0}; // P 操作
        semop(semid, &sb, 1);
        std::cout << "Child in critical section" << std::endl;
        sleep(2);
        sb.sem_op = 1; // V 操作
        semop(semid, &sb, 1);
    } else { // 父进程
        struct sembuf sb = {0, -1, 0}; // P 操作
        semop(semid, &sb, 1);
        std::cout << "Parent in critical section" << std::endl;
        sleep(2);
        sb.sem_op = 1; // V 操作
        semop(semid, &sb, 1);
        wait(NULL);
        semctl(semid, 0, IPC_RMID); // 删除信号量
    }

    return 0;
}

6. 套接字（Socket）

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in server_addr;

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    listen(sockfd, 3);

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        int new_sock = accept(sockfd, NULL, NULL);
        char buffer[1024] = {0};
        read(new_sock, buffer, 1024);
        std::cout << "Child read: " << buffer << std::endl;
        close(new_sock);
    } else { // 父进程
        sleep(1); // 确保子进程先等待连接
        int client_sock = socket(AF_INET, SOCK_STREAM, 0);
        connect(client_sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
        send(client_sock, "Hello from parent", strlen("Hello from parent"), 0);
        close(client_sock);
        wait(NULL);
    }

    close(sockfd);
    return 0;
}

7. 文件（File）

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

#define FILENAME "ipcfile.txt"

int main() {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        sleep(1); // 确保父进程先写入
        std::ifstream infile(FILENAME);
        std::string content;
        infile >> content;
        std::cout << "Child read: " << content << std::endl;
        infile.close();
    } else { // 父进程
        std::ofstream outfile(FILENAME);
        outfile << "Hello from parent";
        outfile.close();
        wait(NULL);
        remove(FILENAME);
    }

    return 0;
}

美丽的欣情
关注
专栏目录
进程间通信
只不停的博客
03-28 339
文章目录进程间通信方式1. 共享存储2.管道通信3. 消息传递 进程间通信方式 在计算机中，每个进程都有自己独立的内存地址空间，其他进程并不能直接访问属于某个进程的地址空间，是为了确保系统数据的安全性。 但举个例子，我们使用图片时，点击分享按钮，可以通过微信将其分享出去，因此此时就需要实现进程之间的相互通信。 进程之间的相互通信方式分为三种： 共享存储 管道通信 消息传递 1. 共享存储 一个...
六种进程间通信方式详解
m0_53263647的博客
08-17 1923
信号的名字和编号：每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO”、“SIGCHLD”等等。信号定义在 signal.h 头文件中，信号名都定义为正整数。具体的信号名称可以使用 kill -l 来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0有特殊的应用。...............
【Unix编程】进程间通信（IPC）
dbbaq24022的专栏
04-21 2366
进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 一、管道 管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。 ...
Linux进程间通信
最新发布
mastershooter的博客
10-16 767
管道是Unix中最古老的进程间通信形式，我们把一个进程连接到另一个进程的数据流称为一个“管道”。我们可以在linux中查看登录用户个数我们可以知道，who和wc是两个命令，首先who进程通过标准输出流将数据打到“管道”中，wc进程再从“管道”中读取数据，从而完成数据的处理who命令是查看云服务器的登录用户（一行显示一个），wc -l用来统计行数所以输出的是用户的个数。
进程间通信方式
weixin_30772105的博客
07-11 153
　　这部分参考文献2：详细内容打开链接看 　　程序员必须让拥有依赖关系的进程集协调，这样才能达到进程的共同目标。可以使用两种技术来达到协调。第一种技术在具有通信依赖关系的两个进程间传递信息。这种技术称做进程间通信（interprocess communication）。第二种技术是同步，当进程间相互具有合作依赖时使用。这两种类型的依赖关系可以同时存在。 一般而言，进程有单独的地址空间。我们可...
进程多线程管道进程间通信网络超详细.pptx
10-25
进程多线程管道进程间通信网络超详细.pptx
UNIX网络编程 第2卷 进程间通信.pdf（带书签）
08-09
第1章对进程间通信的概念进行简要介绍，而第2章则详细介绍TCP、UDP和SCTP等传输层协议的原理和使用场景。TCP是一种面向连接的、可靠的传输协议，适用于需要保障数据完整性和顺序的场合；UDP作为一种无连接的协议，它...
进程间通信—IPC（InterProcess Communication）
SCT_CX的博客
02-18 774
进程间通信
进程间通信（IPC）介绍
MRDOCMAN的博客
05-26 4783
进程间通信（IPC）介绍
进程间通讯
汪子涵的博客
02-22 320
Linux进程间通讯方式：管道、消息队列、共享内存、Socket Binder产生的背景：为了方便程序开发，系统提供了大量服务，但只有Socket支持Client-Server模式，当然也可以在这些底层机制上架设一套协议来实现Client-Server通信，但这样增加了系统的复杂性，另外，Socket作为一款通用接口，其开销大，传输效率低，主要用在跨网络的进程间通信；消息队列和管道采用存储-转发...
探索Linux进程间通信工具与编程基础
"深入浅出Linux工具与编程"是一本详细介绍Linux系统中进程间通信技术的书籍，其中章节涵盖了多种通信机制。首先，作者强调了shell在Linux中的重要性，尽管有些人认为它过时，但实际上，shell是Linux的强大工具，类似...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

美丽的欣情

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值