Linux-进程间通信（IPC）

琢瑜2024-06-30 12:52

进程间通信（IPC）介绍

进程间通信（IPC，InterProcess Communication）是指在不同的进程之间传播或交换信息。IPC 的方式包括管道（无名管道和命名管道）、消息队列、信号量、共享内存、Socket、Streams 等。其中 Socket 和 Streams 支持不同主机上的两个进程间通信。

1. 管道

1.1 无名管道

1.1.1 特点
  • 它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
  • 它只能用于父子进程之间的通信。
  • 管道是创建在内存中，进程结束空间释放，管道不复存在。对于它的读写可以使用普通的 read、write 等函数。
1.1.2 函数原型
cpp 复制代码 
#include <unistd.h>
int pipe(int pipefd[2]);
1.1.3 返回值

成功返回 0，失败返回 -1。当一个管道建立时，它会创建两个文件描述符：fd[0] 为读而打开，fd[1] 为写而打开。

1.1.4 无名管道代码示例
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main() {
    int fd[2];
    int pid;
    char buf[128];

    if (pipe(fd) == -1) {
        printf("create pipe fail\n");
    }

    pid = fork();

    if (pid < 0) {
        printf("create child fail\n");
    } else if (pid > 0) {
        sleep(3);
        printf("this is father\n");
        close(fd[0]);
        write(fd[1], "hello from father", strlen("hello from father"));
        wait(NULL);
    } else {
        printf("this is child\n");
        close(fd[1]);
        read(fd[0], buf, 128);
        printf("read = %s \n", buf);
        exit(0);
    }
    return 0;
}

注意：管道的特性：管道里没有数据时会阻塞。

1.2 命名管道

1.2.1 特点
  • 命名管道可以在无关的进程之间交换数据，与无名管道不同。
  • 命名管道有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
1.2.2 函数原型
cpp 复制代码 
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
1.2.3 命名管道代码示例

read.c

cpp 复制代码 
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd;
    char buf[128] = {0};

    if (mkfifo("./file", 0600) == -1 && errno != EEXIST) {
        printf("mkfifo fail\n");
        perror("why");
    }

    fd = open("./file", O_RDONLY);
    printf("read open success\n");

    while (1) {
        int n_read = read(fd, buf, 128);
        printf("read %d byte, context = %s \n", n_read, buf);
    }

    close(fd);
    return 0;
}

write.c

cpp 复制代码 
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd;
    char *str = "message from fifo";

    fd = open("./file", O_WRONLY);
    printf("write open success\n");

    while (1) {
        write(fd, str, strlen(str));
        sleep(1);
    }
    close(fd);
    return 0;
}

2. 消息队列

消息队列是信息的链接表，存放在内核中。一个消息队列由一个标识符（即队列 ID）来标识。

2.1 特点

  • 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
  • 消息队列独立于发送与接收进程。进程终止时，消息队列及内容并不会删除。
  • 消息队列可以实现信息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取。

2.2 函数原型

cpp 复制代码 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgget(key_t key, int msgflg);
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

2.3 消息队列代码示例

send.c

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

struct msgbuf {
    long mtype;
    char mtext[128];
};

int main() {
    struct msgbuf sendBuf = {888, "this is msg from queue"};
    struct msgbuf readBuf;
    key_t key = ftok(".", 1);
    printf("key=%d\n", key);

    int msgId = msgget(key, IPC_CREAT | 0777);
    if (msgId == -1) {
        perror("why:");
    }

    while (1) {
        msgsnd(msgId, &sendBuf, strlen(sendBuf.mtext), 0);
        sleep(1);
        printf("write success\n");

        msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 988, 0);
        sleep(1);
        printf("read from queue: %s\n", readBuf.mtext);
    }

    msgctl(msgId, IPC_RMID, NULL);
    return 0;
}

read.c

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

struct msgbuf {
    long mtype;
    char mtext[128];
};

int main() {
    struct msgbuf readBuf;
    struct msgbuf sendBuf = {988, "this is msg from father"};
    key_t key = ftok(".", 1);
    printf("key=%d\n", key);

    int msgId = msgget(key, IPC_CREAT | 0777);
    if (msgId == -1) {
        perror("why:");
    }

    while (1) {
        msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 888, 0);
        sleep(1);
        printf("read from queue: %s\n", readBuf.mtext);

        msgsnd(msgId, &sendBuf, strlen(sendBuf.mtext), 0);
        sleep(1);
        printf("write success\n");
    }

    msgctl(msgId, IPC_RMID, NULL);
    return 0;
}

3. 信号

3.1 信号的处理

信号的处理有三种方法：忽略、捕捉和默认动作。具体的信号默认动作可以使用 man 7 signal 来查看系统的具体定义。

3.2 信号处理函数的注册

信号处理函数的注册可以分为入门版和高级版：

  • 入门版：signal 函数
  • 高级版：sigaction 函数

3.3 信号处理发送函数

信号发送函数也分为入门版和高级版：

  • 入门版：kill
  • 高级版：sigqueue

3.4 signal 函数原型及示例

cpp 复制代码 
#include <signal.h>

typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

示例

cpp 复制代码 
#include <signal.h>
#include <stdio.h>

void handler(int signum) {
    printf("get signum = %d\n", signum);
    switch (signum) {
        case SIGINT:
            printf("SIGINT\n");
            break;
        case SIGKILL:
            printf("SIGKILL\n");
            break;
        case SIGUSR1:
            printf("SIGUSR1\n");
            break;
    }
}

int main() {
    signal(SIGINT, handler);
    signal(SIGKILL, handler);
    signal(SIGUSR1, handler);
    while (1);
    return 0;
}

3.5 kill 函数原型及示例

cpp 复制代码 
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

示例

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>

int main(int argc, char **argv) {
    int signum = atoi(argv[1]);
    int pid = atoi(argv[2]);
    printf("signum = %d , pid = %d \n", signum, pid);
    kill(pid, signum);
    printf("send signal ok\n");
    return 0;
}

4. 信号量

信号量（semaphore）是一个计数器，用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。

4.1 特点

  • 信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
  • 信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
  • 支持信号量组。

4.2 函数原型

cpp 复制代码 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);
int semop(int semid, struct sembuf *sops, unsigned nsops);
int semctl(int semid, int semnum, int cmd, ...);

4.3 信号量代码示例

cpp 复制代码 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>

//联合体，用于 semctl 初始化
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

void pGetKey(int id) {
    struct sembuf set;
    set.sem_num = 0;
    set.sem_op = -1;
    set.sem_flg = SEM_UNDO;
    semop(id, &set, 1);
    printf("get key\n");
}

void pPutBackKey(int id) {
    struct sembuf set;
    set.sem_num = 0;
    set.sem_op = 1;
    set.sem_flg = SEM_UNDO;
    semop(id, &set, 1);
    printf("put back the key\n");
}

int main() {
    int semid;
    key_t key = ftok(".", 2);

    //1. 获取或创建信号量
    semid = semget(key, 1, IPC_CREAT | 0666);

    union semun initsem;
    initsem.val = 0;

    //2. 初始化信号量
    semctl(semid, 0, SETVAL, initsem);

    int pid = fork();
    if (pid > 0) {
        //4. 拿锁
        pGetKey(semid);
        printf("this is father\n");

        //5. 还锁
        pPutBackKey(semid);

        //6. 销毁锁
        semctl(semid, 0, IPC_RMID);
    } else if (pid == 0) {
        printf("this is child\n");
        //3. 放锁
        pPutBackKey(semid);
    } else {
        printf("fork error\n");
    }

    return 0;
}

5. 共享内存

共享内存（shared memory）指两个或多个进程共享一个给定的存储区。

5.1 特点

  • 共享内存是最快的一种 IPC，因为进程是直接对内存进行存储，而不需要任何数据的拷贝。
  • 只能单独一个进程写或读，如果 A 和 B 进程同时写，会造成数据的混乱（需要搭配信号量来使用）。

5.2 函数原型

cpp 复制代码 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);
void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

5.3 共享内存代码示例

shm_write.c

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    int shmid;
    char *shmaddr;
    key_t key = ftok(".", 1);

    // 创建共享内存
    shmid = shmget(key, 1024 * 4, IPC_CREAT | 0600);
    if (shmid == -1) {
        printf("create shm fail\n");
        exit(-1);
    }

    // 连接映射共享内存
    shmaddr = shmat(shmid, 0, 0);
    printf("shmat OK\n");

    // 将数据拷贝到共享内存
    strcpy(shmaddr, "hello world\n");

    sleep(5); // 等待 5 秒，避免一下子断开连接。等待另外一个进程读完。

    // 断开共享内存连接
    shmdt(shmaddr);

    // 删除共享内存
    shmctl(shmid, IPC_RMID, 0);

    printf("quit\n");
    return 0;
}

shm_get.c

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    int shmid;
    char *shmaddr;
    key_t key = ftok(".", 1);

    // 打开共享内存
    shmid = shmget(key, 1024 * 4, 0);
    if (shmid == -1) {
        printf("create shm fail\n");
        exit(-1);
    }

    // 连接并映射共享内存
    shmaddr = shmat(shmid, 0, 0);
    printf("get from shm_write message is: %s", shmaddr);

    // 断开共享内存连接
    shmdt(shmaddr);

    printf("quit\n");
    return 0;
}

6. 结合消息队列、共享内存、信号量的示例

6.1 代码示例

get.c

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <string.h>

// 消息队列结构
struct msg_form {
    long mtype;
    char mtext;
};

// 联合体，用于 semctl 初始化
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

// 初始化信号量
int init_sem(int sem_id, int value) {
    union semun tmp;
    tmp.val = value;
    if (semctl(sem_id, 0, SETVAL, tmp) == -1) {
        perror("Init Semaphore Error");
        return -1;
    }
    return 0;
}

// P 操作
int sem_p(int sem_id) {
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = -1;
    sbuf.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sbuf, 1) == -1) {
        perror("P operation Error");
        return -1;
    }
    return 0;
}

// V 操作
int sem_v(int sem_id) {
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = 1;
    sbuf.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sbuf, 1) == -1) {
        perror("V operation Error");
        return -1;
    }
    return 0;
}

// 删除信号量集
int del_sem(int sem_id) {
    union semun tmp;
    if (semctl(sem_id, 0, IPC_RMID, tmp) == -1) {
        perror("Delete Semaphore Error");
        return -1;
    }
    return 0;
}

// 创建一个信号量集
int create_sem(key_t key) {
    int sem_id;
    if ((sem_id = semget(key, 1, IPC_CREAT | 0666)) == -1) {
        perror("semget error");
        exit(-1);
    }
    init_sem(sem_id, 1);  // 初值设为 1 资源未占用
    return sem_id;
}

int main() {
    key_t key;
    int shmid, semid, msqid;
    char *shm;
    struct shmid_ds buf1;  // 用于删除共享内存
    struct msqid_ds buf2;  // 用于删除消息队列
    struct msg_form msg;   // 消息队列用于通知对方更新了共享内存

    // 获取 key 值
    if ((key = ftok(".", 'z')) < 0) {
        perror("ftok error");
        exit(1);
    }

    // 创建共享内存
    if ((shmid = shmget(key, 1024, IPC_CREAT | 0666)) == -1) {
        perror("Create Shared Memory Error");
        exit(1);
    }

    // 连接共享内存
    shm = (char *)shmat(shmid, 0, 0);
    if ((int)shm == -1) {
        perror("Attach Shared Memory Error");
        exit(1);
    }

    // 创建消息队列
    if ((msqid = msgget(key, IPC_CREAT | 0777)) == -1) {
        perror("msgget error");
        exit(1);
    }

    // 创建信号量
    semid = create_sem(key);

    // 读数据
    while (1) {
        msgrcv(msqid, &msg, 1, 888, 0);  // 读取类型为 888 的消息
        if (msg.mtext == 'q')  // quit - 跳出循环
            break;
        if (msg.mtext == 'r')  // read - 读共享内存
        {
            sem_p(semid);
            printf("%s\n", shm);
            sem_v(semid);
        }
    }

    // 断开连接
    shmdt(shm);

    // 删除共享内存、消息队列、信号量
    shmctl(shmid, IPC_RMID, &buf1);
    msgctl(msqid, IPC_RMID, &buf2);
    del_sem(semid);

    return 0;
}

send.c

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <string.h>

// 消息队列结构
struct msg_form {
    long mtype;
    char mtext;
};

// 联合体，用于 semctl 初始化
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

// P 操作
int sem_p(int sem_id) {
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = -1;
    sbuf.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sbuf, 1) == -1) {
        perror("P operation Error");
        return -1;
    }
    return 0;
}

// V 操作
int sem_v(int sem_id) {
    struct sembuf sbuf;
    sbuf.sem_num = 0;
    sbuf.sem_op = 1;
    sbuf.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sbuf, 1) == -1) {
        perror("V operation Error");
        return -1;
    }
    return 0;
}

int main() {
    key_t key;
    int shmid, semid, msqid;
    char *shm;
    struct msg_form msg;
    int flag = 1;  // while 循环条件

    // 获取 key 值
    if ((key = ftok(".", 'z')) < 0) {
        perror("ftok error");
        exit(1);
    }

    // 获取共享内存
    if ((shmid = shmget(key, 1024, 0)) == -1) {
        perror("shmget error");
        exit(1);
    }

    // 连接共享内存
    shm = (char *)shmat(shmid, 0, 0);
    if ((int)shm == -1) {
        perror("Attach Shared Memory Error");
        exit(1);
    }

    // 创建消息队列
    if ((msqid = msgget(key, 0)) == -1) {
        perror("msgget error");
        exit(1);
    }

    // 获取信号量
    if ((semid = semget(key, 0, 0)) == -1) {
        perror("semget error");
        exit(1);
    }

    // 写数据
    printf("***************************************\n");
    printf("*                 IPC                 *\n");
    printf("*    Input r to send data to server.  *\n");
    printf("*    Input q to quit.                 *\n");
    printf("***************************************\n");

    while (flag) {
        char c;
        printf("Please input command: ");
        scanf("%c", &c);
        switch (c) {
            case 'r':
                printf("Data to send: ");
                sem_p(semid);  // 访问资源
                scanf("%s", shm);
                sem_v(semid);  // 释放资源
                // 清空标准输入缓冲区
                while ((c = getchar()) != '\n' && c != EOF);
                msg.mtype = 888;
                msg.mtext = 'r';  // 发送消息通知服务器读数据
                msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
                break;
            case 'q':
                msg.mtype = 888;
                msg.mtext = 'q';
                msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
                flag = 0;
                break;
            default:
                printf("Wrong input!\n");
                // 清空标准输入缓冲区
                while ((c = getchar()) != '\n' && c != EOF);
        }
    }

    // 断开连接
    shmdt(shm);

    return 0;
}

7. 对比总结

通过上述对比可以看出，各种 IPC 方式各有优劣，选择合适的方式进行进程间通信可以提高程序的效率和可靠性。

相关推荐
孤客网络科技工作室6 分钟前
VMware 虚拟机使用教程及 Kali Linux 安装指南
linux·虚拟机·kali linux
颇有几分姿色1 小时前
深入理解 Linux 内存管理：free 命令详解
linux·运维·服务器
AndyFrank1 小时前
mac crontab 不能使用问题简记
linux·运维·macos
筱源源2 小时前
Kafka-linux环境部署
linux·kafka
算法与编程之美2 小时前
文件的写入与读取
linux·运维·服务器
xianwu5433 小时前
反向代理模块
linux·开发语言·网络·git
Amelio_Ming3 小时前
Permissions 0755 for ‘/etc/ssh/ssh_host_rsa_key‘ are too open.问题解决
linux·运维·ssh
Ven%4 小时前
centos查看硬盘资源使用情况命令大全
linux·运维·centos
TeYiToKu4 小时前
笔记整理—linux驱动开发部分（9）framebuffer驱动框架
linux·c语言·arm开发·驱动开发·笔记·嵌入式硬件·arm
dsywws4 小时前
Linux学习笔记之时间日期和查找和解压缩指令
linux·笔记·学习
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解