IPC对象；消息队列；共享内存；信号灯

IPC对象：
内存文件 

1.ipcs 
  查看所有ipc对象的信息

2.ipcrm 
  ipcrm -Q/M/S  Key
  ipcrm -q/m/s  消息队列ID/共享内存ID/信号灯ID

1.消息队列：
    1.创建IPC对象名称
    2.创建消息队列
    3.发送消息
    4.接收消息
    5.消息队列销毁

2.函数接口:
    1.ftok 
    key_t ftok(const char *pathname, int proj_id);
    功能：
        创建一个IPC对象名称
    参数：
        pathname:文件的路径
        proj_id:项目ID（8bits）
    返回值：
        成功返回IPC对象名称
        失败返回-1

    2.msgget 
    int msgget(key_t key, int msgflg);
    功能：
        创建一个消息队列 
    参数：
        key:IPC对象名称 
        msgflg:消息队列属性
            IPC_CREAT：创建一个消息队列
            IPC_EXCL: 如果消息队列存在就报错
    返回值：
        成功返回消息队列ID
        失败返回 -1 

    3.msgsnd 
      int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
      功能：
        向消息队列中发送消息
      参数：
        msqid:消息队列的ID号
        msgp:发送消息的内容
        msgsz:发送消息的大小
        msgflg:消息属性 默认为0 
      返回值：
        成功返回0
        失败返回-1 

        struct msgbuf {
            long mtype;       /* message type, must be > 0 */
            char mtext[1];    /* message data */
        };

    4.msgrcv 
      ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
      功能：
        从消息队列中接收消息
      参数:
        msqid:消息队列的ID号
        msgp:存放消息的空间首地址
        msgsz:最多接收消息的大小
        msgtyp:接收消息的类型 
        msgflg:消息属性 默认为0
      返回值：
        成功返回接收到数据的字节数 
        失败返回-1 

    5.msgctl 
      int msgctl(int msqid, int cmd, struct msqid_ds *buf);
      功能:
        向消息队列发送命令
      参数:
        msqid:消息队列的ID号
        cmd:命令 
            IPC_STAT：获取消息队列的信息 
      返回值:
        成功返回0
        失败返回-1

#include "../head.h"

typedef struct msg 
{
    long mtype;                     //发送消息的类型
    char mtext[256];                //发送的消息
}message_t;

int main(void)
{
    key_t key;
    int msgid = -1;
    int ret = 0;
    message_t sendmsg;
    message_t recvmsg;
    ssize_t nsize = 0;

    //1.生成key值
    key = ftok("/", 'a');
    if (-1 == key)
    {
        return -1;
    }

    printf("%#x\n", key);

    //2.创建消息队列
    msgid = msgget(key, IPC_CREAT | 0664);
    if (-1 == msgid)
    {
        return -1;
    }

    printf("msgid = %d\n", msgid);

    //3.发送消息
    sendmsg.mtype = 100;
    strcpy(sendmsg.mtext, "hello world");
    ret = msgsnd(msgid, &sendmsg, sizeof(sendmsg) - sizeof(long), 0);
    if (-1 == ret)
    {
        return -1;
    }

    printf("发送成功!\n");

    sendmsg.mtype = 200;
    strcpy(sendmsg.mtext, "how are you");
    ret = msgsnd(msgid, &sendmsg, sizeof(sendmsg) - sizeof(long), 0);
    if (-1 == ret)
    {
        return -1;
    }

    printf("发送成功!\n");

    nsize = msgrcv(msgid, &recvmsg, sizeof(recvmsg.mtext), 100, 0);
    if (-1 == nsize)
    {
        return -1;
    }

    printf("接收到 %ld 字节,内容为: %s\n", nsize, recvmsg.mtext);

    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

练习：
1.编写两个进程，实现利用消息队列的通信
    send.c  创建消息队列 -> 发送消息
    recv.c  创建消息队列 -> 接收消息 -> 销毁消息队列

共享内存：
    进程间通信最高效的方法
    操作步骤：
       1.创建 key 值
       2.创建共享内存 
       3.映射共享内存
       4.解除映射
       5.销毁共享内存 

    1.函数接口:
        1.ftok 
        2.shmget 
          int shmget(key_t key, size_t size, int shmflg);
          功能:
            创建一个共享内存
          参数:
            key:IPC对象名称
            size:共享内存的大小
            shmflg:
                IPC_CREAT  创建 
                IPC_EXCL   如果存在就报错 
          返回值:
            成功返回共享内存ID号
            失败返回-1 

        3.shmat
          void *shmat(int shmid, const void *shmaddr, int shmflg);
          功能:
            将地址映射到共享内存中
          参数:
            shmid:共享内存ID号
            shmaddr:
                NULL: 让系统选择一个合适的地址映射到共享内存中
            shmflg:
                属性,默认为0 
          返回值:
            成功返回映射到共享空间的地址
            失败返回NULL

        4.shmdt
          int shmdt(const void *shmaddr);
          功能:
            解除映射空间
          参数:
            shmaddr:映射到共享内存中的地址
          返回值:
            成功返回0 
            失败返回-1 

        5.shmctl 
          int shmctl(int shmid, int cmd, struct shmid_ds *buf);
          功能:
            向共享内存发送命令
          参数:
            shmid:共享内存ID号
             cmd:命令
                IPC_RMID 删除
          返回值:
            成功返回0 
            失败返回-1 

#include "../head.h"

int main(void)
{
    //1.创建 key 值 
    key_t key;
    int shmid = 0;
    int ret = 0;
    char *pshmaddr = NULL;

    key = ftok("/", 'c');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }
    
    //2.创建共享内存 
    shmid = shmget(key, 4096, IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }

    //3.映射到共享内存中
    pshmaddr = shmat(shmid, NULL, 0);
    if (NULL == pshmaddr)
    {
        perror("fail to shmat");
        return -1;
    }

    fgets(pshmaddr, 4096, stdin);
    pshmaddr[strlen(pshmaddr)-1] = '\0';

    printf("共享空间: %s\n", pshmaddr);

    //4.解除映射
    ret = shmdt(pshmaddr);
    if (-1 == ret)
    {
        perror("fail to shmdt");
        return -1;
    }

    //5.销毁共享空间
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

练习：
1.编写两个进程，实现利用共享内存的通信
    write.c  创建共享内存 -> 映射 -> 从终端接收数据写入共享内存中
    read.c  创建共享内存 -> 映射 -> 从共享内存中读取数据 -> 显示到终端

信号灯:
    有名信号量数组
    1.创建信号灯 
        int semget(key_t key, int nsems, int semflg);   
        功能：
            创建信号量数组 
        参数： 
            key:IPC对象名称
            nsems:信号量个数
            semflg:信号量属性
                IPC_CREAT：创建一个信号量数组
        返回值：    
            成功返回0 
            失败返回-1 

    2.向信号灯发送命令 
        int semctl(int semid, int semnum, int cmd, ...);
        功能:
            向信号灯发送命令
        参数:
            IPC_RMID    删除信号灯
            SETVAL      设置第semnum-th信号量的值为arg.val 
        返回值:
            成功返回0 
            失败返回-1 

    3.对信号量完成申请和释放操作
        int semop(int semid, struct sembuf *sops, size_t nsops);
        功能：
            对信号量完成申请和释放操作
        参数：
            semid:信号灯ID号
            sops:信号灯操作数组
                unsigned short sem_num;  //操作信号量的下标
                short          sem_op;   //对信号量的操作 +1(释放信号量) -1(申请信号量)
                short          sem_flg;  //SEM_UNDO 操作结束后,信号量的值会恢复到原来的值
            nsops:数组元素个数  
        返回值：
            成功返回0 
            失败返回-1

#include "../head.h"

int main(void)
{
    //1.创建IPC对象名称 
    key_t key;
    int semid = 0;
    union semun myun;
    struct sembuf mybuf;
    int ret = 0;

    key = ftok("/", 'a');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    //2.创建信号量数组 
    semid = semget(key, 2, IPC_CREAT | 0664);
    if (-1 == semid)
    {
        perror("fail to semget");
        return -1;
    }

    //将下标为0的读信号量设置为0 
    myun.val = 0;
    ret = semctl(semid, 0, SETVAL, myun);
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    }

    //将下标为1的写信号量设置为1 
    myun.val = 1;
    ret = semctl(semid, 1, SETVAL, myun);
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    }

    //申请写信号量
    mybuf.sem_num = 1;
    mybuf.sem_op = -1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if (-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("拿到写信号量了!\n");

    //释放读信号量
    mybuf.sem_num = 0;
    mybuf.sem_op = +1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if (-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("释放读信号量了!\n");

    //申请读信号量
    mybuf.sem_num = 0;
    mybuf.sem_op = -1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if (-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("申请读信号量了!\n");

    //申请读信号量
    mybuf.sem_num = 0;
    mybuf.sem_op = -1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if (-1 == ret)
    {
        perror("fail to semop");
        return -1;
    }

    printf("申请读信号量了!\n");

    return 0;
}