【C语言】【unix c】system v IPC（进程间的通信的一种方式）

Bertha 。 2022-06-06 22:22 140阅读 0赞

六、system v IPC（进程间的通信的一种方式）
        消息队列 共享内存 信号量集
    
        在内核管理的内存，用于进程间通讯的内存，称为system v IPC object
    
        操作系统需要管理这些对象。
    
        如何察看当前系统里有哪些对象：ipcs
    
            tarena@ubuntu:~$ ipcs
    
            ------ Shared Memory Segments --------
            key        shmid      owner      perms      bytes      nattch     status      
            0x00000000 0          tarena     600        393216     2          dest         
            0x00000000 32769      tarena     600        393216     2          dest         
    
            ------ Semaphore Arrays --------
            key        semid      owner      perms      nsems     
    
            ------ Message Queues --------
            key        msqid      owner      perms      used-bytes   messages    
    
    
        在操作系统中这些对象，每一个都有自己的id。便于操作系统的管理。
    
        在用户态需要获取这些对象的id。
        获取这些对象的id。需要在用户态有一个键值（唯一的）
    
        将键值和id绑定，这样就可以获取到对象的id。
    
        如何获取这个键值：
            ftok（3）
                #include <sys/types.h>
                #include <sys/ipc.h>
                key_t ftok(const char *pathname, int proj_id);
    
                    功能：获取system v IPC的一个键值 key
                    参数：
                    pathname：指定一个文件名，这个文件是存在的可访问的，一般是当前目录
                    proj_id：必须是非0，取这个数的有效低8位
                        这个值自己定一个然后与文件的索引节点号组合为一个8位的
                        例如自己定的为38转16进制为0X26，文件索引节点号为65538，转16进制为0X010002则key_t返回值为0X26010002
                    返回值： -1 错误 errno被设置
                        成功：返回一个key值
    
                举例：使用ftok获取一个键值（ftok.c）
                    #include <stdio.h>
                    #include <sys/types.h>
                    #include <sys/ipc.h>
    
                    int main(void) {
                        key_t key;
                        key = ftok(".",21);//？？？？？？？？？？？？？？？？？
                        if(key == -1) {
                        perror("ftok");
                        return -1;
                    }
                    printf("key=%x\n",key);
                    return 0;
                    }
                    tarena@ubuntu:~/day/day33$ a.out 
                    key=15081b76
    
        消息队列：
            从系统中获取一个消息队列，如果系统里没有，创建消息队列，将这个消息队列的id给我返回。如果有这个消息队列，返回id即可。
            msgget(2)
                #include <sys/types.h>
                #include <sys/ipc.h>
                #include <sys/msg.h>
                int msgget(key_t key, int msgflg);
                    功能：获取一个消息队列的ID
                    参数：
                        key：ftok(3)的返回值
                        msgflg：
                            IPC_CREAT：如果不存在创建，存在的话不创建
                            IPC_EXCL：和IPC_CREAT一起指定，若文件存在就报错
                        mode：指定了消息队列的权限
                    返回值：
                        成功 返回消息队列的id
                        错误 -1 errno被设置
    
            举例说明，使用msgget从内核获取消息队列（msgget.c）
                #include <stdio.h>
                #include <sys/types.h>
                #include <sys/ipc.h>
                #include <sys/msg.h>
    
                int main(void) {
                key_t key;
                key = ftok(".",21); //不同文件产生的key不同
                if(key == -1) {
                    perror("ftok");
                    return -1;
                }
                printf("key=%x\n",key);
                //从内核获取消息队列
                int msqid = msgget(key, IPC_CREAT|0664); //获取ID，如果没有消息队列就创建
                if(msqid == -1) {
                    perror("MSGGET");
                    return -1;
                }
                printf("msqid=0x%x\n",msqid);
                return 0;
                }
    
                tarena@ubuntu:~/day/day33$ a.out 
                key=15081b76
                msqid=0x0
                tarena@ubuntu:~/day/day33$ ipcs
    
                ------ Shared Memory Segments --------
                key        shmid      owner      perms      bytes      nattch     status      
                0x00000000 0          tarena     600        393216     2          dest         
                0x00000000 32769      tarena     600        393216     2          dest         
    
                ------ Semaphore Arrays --------
                key        semid      owner      perms      nsems     
    
                ------ Message Queues --------
                key        msqid      owner      perms      used-bytes   messages    
                0x15081b76 0          tarena     664        0            0           
    
            向消息队列发送消息和接受消息
            msgsnd(2)
                #include <sys/types.h>
                #include <sys/ipc.h>
                #include <sys/msg.h>
                int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
                    功能：向消息队列发送消息
                    参数：
                        msqid：指定了存放消息的消息队列的id
                        msgp：指向了消息的地址
                        msgsz：指定了消息内容的长度
                        msgflg：
                            IPC_NOWAIT：没有消息的时候，立即返回错误   errno被设置
                            0    没有消息的时候，阻塞等待
                    返回值：-1 失败errno被设置
                        0  成功
                    注意：将一份拷贝追加到消息队列
    
                ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
                    功能：从消息队列接收消息
                    参数：
                        msqid：指定了存放消息的消息队列的id
                        msgp：指向了消息的地址
                        msgsz：指定了消息内容的长度
                        msgtyp：指定了消息的类型
                        msgflg：
                            IPC_NOWAIT：列对中没有消息非阻塞
                            0 列对中没有消息阻塞
    
                需要用户自定义这个类型：
                    struct msgbuf {
                               long mtype;       /* message type, must be > 0 */  消息类型
                               char mtext[2];    /* message data */  // 这是一个可变长的数组，
                           };
                    返回值：-1 失败errno被设置
                        0  成功
    
            举例说明，两个进程通过消息队列实现进程间的通信（send.c recv.c）
            send.c:
                #include <stdio.h>
                #include <sys/types.h>
                #include <sys/ipc.h>
                #include <sys/msg.h>
                #include <string.h>
                typedef struct msgbuf{ //函数要求用户自定义一个结构体
                    long mtype;
                    char mtext[128];
                }msg_t;
    
                int main(void) {
                    key_t key;
                    msg_t mbuf;
                    key = ftok(".",21);  //获得一个键值
                    if(key == -1) {
                    perror("ftok");
                    return -1;
                    }
                    printf("key=%x\n",key);
                    //从内核获取消息队列
                    int msqid = msgget(key, IPC_CREAT|0664);
                    if(msqid == -1) {
                    perror("MSGGET");
                    return -1;
                    }
                    printf("msqid=0x%x\n",msqid);
                    //初始化消息
                    mbuf.mtype = 3;
                    strcpy(mbuf.mtext,"this is a test\n");
                    //向消息队列发送消息
                    int s = msgsnd(msqid, &mbuf, strlen(mbuf.mtext)+1, 0);
                    if(s == -1) {
                    perror("msgsnd");
                    return -1;
                    }
    
                    return 0;
                }
                tarena@ubuntu:~/day/day33$ a.out 
                key=15081b76
                msqid=0x0
                tarena@ubuntu:~/day$ ipcs
    
                ------ Shared Memory Segments --------
                key        shmid      owner      perms      bytes      nattch     status      
                0x00000000 0          tarena     600        393216     2          dest         
                0x00000000 32769      tarena     600        393216     2          dest         
    
                ------ Semaphore Arrays --------
                key        semid      owner      perms      nsems     
    
                ------ Message Queues --------
                key        msqid      owner      perms      used-bytes   messages    
                0x15081b76 0          tarena     664        15           1            //执行一次，写入一次消息，再执行一次会继续追加
            recv.c:
                #include <stdio.h>
                #include <sys/types.h>
                #include <sys/ipc.h>
                #include <sys/msg.h>
                #include <string.h>
                typedef struct msgbuf{
                    long mtype;
                    char mtext[128];
                }msg_t;
    
                int main(void) {
                    key_t key;
                    msg_t mbuf;
                    key = ftok(".",21);
                    if(key == -1) {
                    perror("ftok");
                    return -1;
                    }
                    printf("key=%x\n",key);
                    //从内核获取消息队列
                    int msqid = msgget(key, IPC_CREAT|0664);
                    if(msqid == -1) {
                    perror("MSGGET");
                    return -1;
                    }
                    printf("msqid=0x%x\n",msqid);
                    //从消息队列获取消息
                    int s = msgrcv(msqid, &mbuf, 128, 3, IPC_NOWAIT);//0是没有消息阻塞
                    if(s == -1) {
                    perror("msgrcv");
                    return -1;
                    }
                    printf("%s\n", mbuf.mtext);
                    return 0;
                }
    
                tarena@ubuntu:~/day/day33$ rec
                key=15081b76
                msqid=0x0
                this is a test
    
                tarena@ubuntu:~/day/day33$ rec
                key=15081b76
                msqid=0x0
                msgrcv: No message of desired type