Linux进程通信2：消息队列，共享内存，信号，信号量.(含：综合实例：实现服务器进程和客户进程通信)

拼搏现实的明天。 2022-12-14 13:31 68阅读 0赞

## 消息队列，共享内存，信号，信号量 ##

**1.消息队列：**

**1.1消息队列的通信原理：**

**消息队列：**

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

**特点：**

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

函数原型：

#include <sys/msg.h>
    // 创建或打开消息队列：成功返回队列ID，失败返回-1
    int msgget(key_t key, int flag);
    // 添加消息：成功返回0，失败返回-1
    int msgsnd(int msqid, const void *ptr, size_t size, int flag);
    // 读取消息：成功返回消息数据的长度，失败返回-1
    int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
    // 控制消息队列：成功返回0，失败返回-1
    int msgctl(int msqid, int cmd, struct msqid_ds *buf);

#include <sys/types.h> 
    #include <sys/ipc.h> 
    #include <sys/msg.h>
    int msgget(key_t key, int msgflg);

如何创建一个消息队列：

A：创建队列，写数据  
B：获取队列，读数据

在以下两种情况下，msgget将创建一个新的消息队列：

> 如果没有与键值key相对应的消息队列，并且flag中包含了IPC\_CREAT标志位。（键值key：标识消息队列）

> 常用key参数为IPC\_PRIVATE。（私有化）

函数msgrcv在读取消息队列时，type参数有下面几种情况:

> type == 0，返回队列中的第一个消息；  
> type > 0，返回队列中消息类型为 type 的第一个消息；  
> type < 0，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。

可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。

**1.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); 
    ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);

接收并回应：  
参考代码：

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    #include <string.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);
    struct msgbuf
    {
        
    long mtype;//必须大于0
    char mtext[128];//内容
    };
    int main()
    {
        
    struct msgbuf readbuf;
    key_t key;
    key=ftok(".",23);//当前路径，id值随便‘Z’
    printf("key=%x\n",key);
    int msgid=msgget(0x1234,IPC_CREAT|0777);//创建队列,权限：可读可写可执行
    if(msgid==-1)
    {
        
    printf("创建队列失败\n");
    }
    msgrcv(msgid,&readbuf,sizeof(readbuf.mtext),888,0);
    printf("读取到：%s\n",readbuf.mtext);//读到的数据
    struct msgbuf sendbuf={
        988,"fanhui de shuju"};//再返回
    msgsnd(msgid,&sendbuf,strlen(sendbuf.mtext),0);
    msgctl(msgid,IPC_RMID,NULL);
    return 0;
    }

发送并接收：

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    #include <string.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);
    struct msgbuf
    {
        
    long mtype;//必须大于0
    char mtext[128];//内容
    };
    int main()
    {
        
    struct msgbuf sendbuf={
        888,"laizi dazai xiaoxi"};
    struct msgbuf readbuf;
    key_t key;
    key=ftok(".",23);//当前路径，id值随便‘Z’
    printf("key=%x\n",key);
    int msgid=msgget(0x1234,IPC_CREAT|0777);//创建队列,权限：可读可写可执行
    if(msgid==-1)
    {
        
    printf("创建队列失败\n");
    }
    msgsnd(msgid,&sendbuf,strlen(sendbuf.mtext),0);//0:非阻塞方式发送
    msgrcv(msgid,&readbuf,sizeof(readbuf.mtext),988,0);//接受返回的数据
    printf("return from get：%s\n",readbuf.mtext);
    msgctl(msgid,IPC_RMID,NULL);
    return 0;
    }

运行结果：

![在这里插入图片描述][20201013194528178.png_pic_center]  
案例演示：

下面写了一个简单的使用消息队列进行IPC的例子：  
服务端程序一直在等待特定类型的消息，当收到该类型的消息以后，发送另一种特定类型的消息作为反馈，客户端读取该反馈并打印出来。

msg\_server.c：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/msg.h>
    // 用于创建一个唯一的key
    #define MSG_FILE "/etc/passwd"
    // 消息结构
    struct msg_form {
        
        long mtype;
        char mtext[256];
    };
    int main()
    {
        
        int msqid;
        key_t key;
        struct msg_form msg;
        // 获取key值
        if((key = ftok(MSG_FILE,'z')) < 0)
        {
        
            perror("ftok error");
            exit(1);
        }
        // 打印key值
        printf("Message Queue - Server key is: %d.\n", key);
        // 创建消息队列
        if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
        {
        
            perror("msgget error");
            exit(1);
        }
        // 打印消息队列ID及进程ID
        printf("My msqid is: %d.\n", msqid);
        printf("My pid is: %d.\n", getpid());
        // 循环读取消息
        for(;;)
        {
        
            msgrcv(msqid, &msg, 256, 888, 0);// 返回类型为888的第一个消息
            printf("Server: receive msg.mtext is: %s.\n", msg.mtext);
            printf("Server: receive msg.mtype is: %d.\n", msg.mtype);
            msg.mtype = 999; // 客户端接收的消息类型
            sprintf(msg.mtext, "hello, I'm server %d", getpid());
            msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
        }
        return 0;
    }

msg\_client.c

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/msg.h>
    // 用于创建一个唯一的key
    #define MSG_FILE "/etc/passwd"
    // 消息结构
    struct msg_form {
        
        long mtype;
        char mtext[256];
    };
    int main()
    {
        
        int msqid;
        key_t key;
        struct msg_form msg;
        // 获取key值
        if ((key = ftok(MSG_FILE, 'z')) < 0)
        {
        
            perror("ftok error");
            exit(1);
        }
        // 打印key值
        printf("Message Queue - Client key is: %d.\n", key);
        // 打开消息队列
        if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
        {
        
            perror("msgget error");
            exit(1);
        }
        // 打印消息队列ID及进程ID
        printf("My msqid is: %d.\n", msqid);
        printf("My pid is: %d.\n", getpid());
        // 添加消息，类型为888
        msg.mtype = 888;
        sprintf(msg.mtext, "hello, I'm client %d", getpid());
        msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
        // 读取类型为777的消息
        msgrcv(msqid, &msg, 256, 999, 0);
        printf("Client: receive msg.mtext is: %s.\n", msg.mtext);
        printf("Client: receive msg.mtype is: %d.\n", msg.mtype);
        return 0;
    }

运行结果：  
![在这里插入图片描述][20201013195405772.png_pic_center]  
**1.3键值生成及消息队列移除：**

**ftok**：系统IPC键值的格式转化函数

系统建立IPC通讯（消息队列，信号量和共享内存）时，必须指定一个ID值，通常情况下，该ID通过ftok函数的到。去内核中找到相应的链表

函数原型：

#include <sys/types.h>
    #include <sys/ipc.h>
    key_t ftok(const char *pathname, int proj_id);

> fname就是你指定的文件名（已经存在的文件名），一般使用当前目录，  
> id是子序号。虽然是int类型，但是只使用8bits(1-255）。  
> key\_t key;key = ftok(".", 1); 这样就是将fname设为当前目录。

在一般的UNIX实现中，是将文件的索引节点号取出，前面加上子序号得到key\_t的返回值。-----利用----ls -ai

> 如指定文件的索引节点号为65538，换算成16进制为0x010002，而你指定的ID值为38，换算成16进制为0x26，则最后的key\_t返回值为0x26010002。

查询文件索引节点号的方法是： ls -i  
\--------------------通过key在内核找到链表（消息队列）没有创建

**1.4.删除链表（消息队列）:**

函数原型：

#include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    int msgctl(int msqid, int cmd, struct msqid_ds *buf);
    关键字：IPC_STAT IPC_SET   IPC_RMID IPC_INFO 。。。。
    // 
    IPC_RMID：移除

**2.共享内存：**

**2.1共享内存的概述：**

进程间的通信（写纸条）：  
无名管道（单方向，写完被拿走），  
命名管道（单方向，写完被拿走），  
消息队列（双全工，写完不拿走），  
共享内存（写在一个纸条上），  
信号，信号量

**共享内存**：指两个或者多个进程共享一个给定的存储区

特点：

> 1.共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。  
> 2.因为多个进程可以同时操作，所以需要进行同步。  
> 3.信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

函数原型（共享内存的API）：

#include <sys/shm.h>
    // 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
    int shmget(key_t key, size_t size, int flag);
    // 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
    void *shmat(int shm_id, const void *addr, int flag);
    // 断开与共享内存的连接：成功返回0，失败返回-1
    int shmdt(void *addr);
    // 控制共享内存的相关信息：成功返回0，失败返回-1
    int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

创建共享内存：

#include <sys/ipc.h>
    #include <sys/shm.h> 
    int shmget(key_t key, size_t size, int shmflg);

连接共享内存：

#include <sys/types.h> 
    #include <sys/shm.h>
    void *shmat(int shmid, const void *shmaddr, int shmflg);
    int shmdt(const void *shmaddr);

断开连接：

#include <sys/types.h>
    #include <sys/shm.h>
    void *shmat(int shmid, const void *shmaddr, int shmflg);
    int shmdt(const void *shmaddr);

关闭共享内存：

#include <sys/ipc.h>
    #include <sys/shm.h>
    int shmctl(int shmid, int cmd, struct shmid_ds *buf);

说明：

> 1.当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。

> 2.当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。

> 3.shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。

> 4.shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC\_RMID（从系统中删除该共享内存）。

演示代码：

写操作：

#include <sys/ipc.h>
    #include <sys/shm.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    //int shmget(key_t key, size_t size, int shmflg);
    int main()
    {
        
    int shmid;
    char *shmaddr;
    key_t key;
    key=ftok(".",1);//获取键值--内核位置
    shmid=shmget(key,1024*4,IPC_CREAT|0666);//共响内存以兆为单位，关键字：创造
    if(shmid==-1)
    {
        
    printf("创建共响内存失败\n");
    exit(-1);//通常设定，异常返回-1,正常返回0
    }
    // void *shmat(int shmid, const void *shmaddr, int shmflg);
    shmaddr=shmat(shmid,0,0);//连接共响内存，shmflg：0：代表映射进来的共响内存可读可写,,完成共项内存的映射
    printf("连接成功\n");
    strcpy(shmaddr,"liujinhui");//写入内容
    sleep(5);//写完后睡5s，让别的程序读走
    //int shmdt(const void *shmaddr);
    shmdt(shmaddr);//断开连接
    //int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    shmctl(shmid,IPC_RMID,0);//关闭共响内存/删除
    printf("退出\n");
    return 0;
    }

读操作：

#include <sys/ipc.h>
    #include <sys/shm.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    //int shmget(key_t key, size_t size, int shmflg);
    int main()
    {
        
    int shmid;
    char *shmaddr;
    key_t key;
    key=ftok(".",1);//获取键值--内核位置
    shmid=shmget(key,1024*4,0);//共响内存以兆为单位，关键字：不创造
    if(shmid==-1)
    {
        
    printf("创建共响内存失败\n");
    exit(-1);//通常设定，异常返回-1,正常返回0
    }
    // void *shmat(int shmid, const void *shmaddr, int shmflg);
    shmaddr=shmat(shmid,0,0);//连接共响内存，shmflg：0：代表映射进来的共响内存可读可写,,完成共项内存的映射
    printf("连接成功\n");
    printf("data:%s\n",shmaddr);//读出内容 
    //int shmdt(const void *shmaddr);
    shmdt(shmaddr);//断开连接
    printf("退出\n");
    return 0;
    }

运行结果：

![在这里插入图片描述][20201013203327581.png_pic_center]  
注意：在./write之后5s内操作./read

//如何查看操作系统中有哪些共享内存：
    ipcs -m
    //删除共享内存：
    ipcrm -m 884736

**要求**：明白共享内存原理，会使用共享内存api

**3.信号**

**3.1信号概述:**

对于linux来说，信号是软中断，许多重要的程序都需要处理信号，信号为linux提供了一种处理异步时间的方法，  
**比如**：终端用户输入ctrl+c来终端程序，会通过信号机制停止一个程序

**3.2信号的名字和编号：**

每个信号都有名字和编号，这些名字都以SIG开头，例如：SIGIO,SIGCHLD等等

信号定义在signal.h文件中，信号名都定义为正整数具体信号可以使用“kill -l”查询信号的名字以及序号，信号是从1开始编号的，不存在0号信号，kill对信号0有特殊的应用

kill -l

Linux信号的编号是从1-64，其中32和33空缺，没有对应的信号。通过kill -l 可查看所有的信号。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center]  
其中：

> 1~31之间的信号叫做不可靠信号, 不支持排队, 信号可能会丢失, 也叫做非实时信号。  
> 34~64之间的信号叫做可靠信号, 支持排队, 信号不会丢失, 也叫做实时信号。

**3.3信号的处理：**

信号的处理有3种方法：忽略，捕捉和默认动作

> 忽略信号：大多数信号可以使用这种方式来处理，但是有两者信号不能被忽略（SIGKILL SIGTOP），因为向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成没人管理的进程。

> 捕捉信号：需要告诉内核，用户希望如何处理某一信号，说白了就是写一个信号处理函数，然后将这个函数告诉内核，当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号机制。

> 系统默认信号：对于每个信号来说，系统都对应有默认的处理动作，当发生了该信号，系统会自动执行，不过，对系统来说，大部分处理方式都比较粗暴，就是直接杀死该进程  
> 具体信号默认动作可以使用 man 7 signal 来查看系统的具体定义。

**3.4.如何使用这些信号：**

Kill：就是一个发送信号的工具

比如：

./a.out(产生进程)
    ----ps -aux|grep a.out(查看进程id)
    ----kill -9 4222（杀死该进程）
    通过查看编号的名称，可以发现9---SIGKILL，正是杀死该进程

对于信号来说，最大的意义并不是杀死进程，  
而是实现一些异步通信的手段-----捕捉信号（信号处理函数）

那么如何来自定义信号的处理函数呢？

**信号处理函数的注册：**

信号处理函数的注册不只一种方法，分为入门版和高级版

入门版：函数signal

高级版：函数sigaction (先不讲)

**信号注册函数——入门版:**

可以发送的信号类型是多种多样的，每种信号的处理可能不一定相同，那么，我们肯定需要知道到底发生了什么信号。

另外，虽然我们知道了系统发出来的是哪种信号，但是还有一点也很重要，就是系统产生了一个信号，是由谁来响应？

如果系统通过 ctrl+c 产生了一个 SIGINT（中断信号），显然不是所有程序同时结束，那么，信号一定需要有一个接收者。对于处理信号的程序来说，接收者就是自己。

signal 的函数原型:

#include <signal.h>
    typedef void (*sighandler_t)(int);
    sighandler_t signal(int signum, sighandler_t handler);

根据函数原型可以看出由两部分组成，一个是真实处理信号的函数，另一个是注册函数了。

对于sighandler\_t signal(int signum, sighandler\_t handler);函数来说，signum 显然是信号的编号，handler 是中断函数的指针。

同样，typedef void (\*sighandler\_t)(int);中断函数的原型中，有一个参数是 int 类型，显然也是信号产生的类型，方便使用一个函数来处理多个信号。我们先来看看简单一个信号注册的代码示例吧。

演示代码：signal.c

#include<signal.h>
    #include<stdio.h>
    #include <unistd.h>
    //typedef void (*sighandler_t)(int);
    void handler(int signum)
    {
        
        if(signum == SIGIO)
            printf("SIGIO   signal: %d\n", signum);
        else if(signum == SIGUSR1)
            printf("SIGUSR1   signal: %d\n", signum);
        else
            printf("error\n");
    }
    int main(void)
    {
        
        //sighandler_t signal(int signum, sighandler_t handler);
        signal(SIGIO, handler);
        signal(SIGUSR1, handler);
        printf("%d  %d\n", SIGIO, SIGUSR1);
        for(;;)
        {
        
            sleep(10000);
        }
        return 0;
    }

我们先使用 kill 命令发送信号给之前所写的程序，关于这个命令，我们后面再谈。

运行结果：  
通过kill发送信号：  
![在这里插入图片描述][20201014162739776.png_pic_center]  
程序接收到的信号处理结果：  
![在这里插入图片描述][20201014162819305.png_pic_center]  
简单的总结一下，我们通过 signal 函数注册一个信号处理函数，分别注册了两个信号（SIGIO 和 SIGUSER1）；随后主程序就一直“长眠”了。

通过 kill 命令发送信号之前，我们需要先查看到接收者，通过 ps 命令查看了之前所写的程序的 PID，通过 kill 函数来发送。

对于已注册的信号，使用 kill 发送都可以正常接收到，但是如果发送了未注册的信号，则会使得应用程序终止进程。

**那么，已经可以设置信号处理函数了，信号的处理还有两种状态，分别是默认处理和忽略，这两种设置很简单，只需要将 handler 设置为 SIG\_IGN（忽略信号）或 SIG\_DFL（默认动作）即可。**

在此还有两个问题需要说明一下：

> 1.当执行一个程序时，所有信号的状态都是系统默认或者忽略状态的。除非是 调用exec进程忽略了某些信号。exec 函数将原先设置为要捕捉的信号都更改为默认动作，其他信号的状态则不会改变 。  
> 2.当一个进程调动了 fork 函数，那么子进程会继承父进程的信号处理方式。

入门版的信号注册还是比较简单的，只需要一句注册和一个处理函数即可，那么，接下来看看，如何发送信号吧。

**信号发送函数——入门版**

kill 的函数原型:

#include <sys/types.h>
    #include <signal.h>
    int kill(pid_t pid, int sig);

正如我之前所说的，信号的处理需要有接受者，显然发送者必须要知道发给谁，根据 kill 函数的原型可以看到，pid 就是接受者的 pid，sig 则是发送的信号的类型。从原型来看，发送信号要比接受信号还要简单些，那么我们直接上代码吧~~！

演示代码：kill.c

#include <sys/types.h>
    #include <signal.h>
    #include<stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    int main(int argc, char** argv)
    {
        
        if(3 != argc)
        {
        
            printf("[Arguments ERROR!]\n");
            printf("\tUsage:\n");
            printf("\t\t%s <Target_PID> <Signal_Number>\n", argv[0]);
            return -1;
        }
        int pid = atoi(argv[1]);
        int sig = atoi(argv[2]);
        //int kill(pid_t pid, int sig);
        if(pid > 0 && sig > 0)
        {
        
            kill(pid, sig);
        }
        else
        {
        
            printf("Target_PID or Signal_Number MUST bigger than 0!\n");
        }  
        return 0;
    }

运行结果：

发送信号：  
![在这里插入图片描述][20201014164126236.png_pic_center]  
接收信号：  
![在这里插入图片描述][20201014164150833.png_pic_center]  
总结一下：

根据以上的结果可看到，基本可以实现了信号的发送，虽然不能直接发送信号名称，但是通过信号的编号，可以正常的给程序发送信号了，也是初步实现了信号的发送流程。

关于 kill 函数，还有一点需要额外说明，上面的程序限定了 pid 必须为大于0的正整数，其实 kill 函数传入的 pid 可以是小于等于0的整数。

> pid > 0：将发送个该 pid 的进程  
> pid == 0：将会把信号发送给与发送进程属于同一进程组的所有进程，并且发送进程具有权限想这些进程发送信号。  
> pid < 0：将信号发送给进程组ID 为 pid 的绝对值得，并且发送进程具有权限向其发送信号的所有进程  
> pid == -1：将该信号发送给发送进程的有权限向他发送信号的所有进程。（不包括系统进程集中的进程）

**信号注册函数——高级版:**

我们已经成功完成了信号的收发，那么为什么会有高级版出现呢？其实之前的信号存在一个问题就是，虽然发送和接收到了信号，可是总感觉少些什么，既然都已经把信号发送过去了，为何不能再携带一些数据呢？

正是如此，我们需要另外的函数来通过信号传递的过程中，携带一些数据。咱么先来看看发送的函数吧。

sigaction 的函数原型:

#include <signal.h>
    int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
    
    struct sigaction {
        
       void       (*sa_handler)(int); //信号处理程序，不接受额外数据，SIG_IGN 为忽略，SIG_DFL 为默认动作
       void       (*sa_sigaction)(int, siginfo_t *, void *); //信号处理程序，能够接受额外数据和sigqueue配合使用
       sigset_t   sa_mask;//阻塞关键字的信号集，可以再调用捕捉函数之前，把信号添加到信号阻塞字，信号捕捉函数返回之前恢复为原先的值。
       int        sa_flags;//影响信号的行为SA_SIGINFO表示能够接受数据
     };
    //回调函数句柄sa_handler、sa_sigaction只能任选其一

这个函数的原版帮助信息，可以通过man sigaction来查看。

关于void (\*sa\_sigaction)(int, siginfo\_t \*, void *);处理函数来说还需要有一些说明。void* 是接收到信号所携带的额外数据；而struct siginfo这个结构体主要适用于记录接收信号的一些相关信息。

siginfo_t {
        
                   int      si_signo;    /* Signal number */
                   int      si_errno;    /* An errno value */
                   int      si_code;     /* Signal code */
                   int      si_trapno;   /* Trap number that caused
                                            hardware-generated signal
                                            (unused on most architectures) */
                   pid_t    si_pid;      /* Sending process ID */
                   uid_t    si_uid;      /* Real user ID of sending process */
                   int      si_status;   /* Exit value or signal */
                   clock_t  si_utime;    /* User time consumed */
                   clock_t  si_stime;    /* System time consumed */
                   sigval_t si_value;    /* Signal value */
                   int      si_int;      /* POSIX.1b signal */
                   void    *si_ptr;      /* POSIX.1b signal */
                   int      si_overrun;  /* Timer overrun count; POSIX.1b timers */
                   int      si_timerid;  /* Timer ID; POSIX.1b timers */
                   void    *si_addr;     /* Memory location which caused fault */
                   int      si_band;     /* Band event */
                   int      si_fd;       /* File descriptor */
    }

其中的成员很多，==si\_signo 和 si\_code ==是必须实现的两个成员。可以通过这个结构体获取到信号的相关信息。

关于发送过来的数据是存在两个地方的，sigval\_t si\_value这个成员中有保存了发送过来的信息；同时，在si\_int或者si\_ptr成员中也保存了对应的数据。

那么，kill 函数发送的信号是无法携带数据的，我们现在还无法验证发送收的部分，那么，我们先来看看发送信号的高级用法后，我们再来看看如何通过信号来携带数据吧。

**信号发送函数——高级版:**

使用这个函数之前，必须要有几个操作需要完成:

> 1.使用 sigaction 函数安装信号处理程序时，制定了 SA\_SIGINFO 的标志。  
> 2.sigaction 结构体中的 sa\_sigaction 成员提供了信号捕捉函数。如果实现的时 sa\_handler 成员，那么将无法获取额外携带的数据。

sigqueue 函数只能把信号发送给单个进程，可以使用 value 参数向信号处理程序传递整数值或者指针值。

sigqueue 函数不但可以发送额外的数据，还可以让信号进行排队，对于设置了阻塞的信号，使用 sigqueue 发送多个同一信号，在解除阻塞时，接受者会接收到发送的信号队列中的信号，而不是直接收到一次。

但是，信号不能无限的排队，信号排队的最大值受到SIGQUEUE\_MAX的限制，达到最大限制后，sigqueue 会失败，errno 会被设置为 EAGAIN。

那么我们来尝试一下，发送一个携带有额外数据的信号吧。

接收端代码：

#include<signal.h>
    #include<stdio.h>
    #include <unistd.h>
    
    //void (*sa_sigaction)(int, siginfo_t *, void *);
    void handler(int signum, siginfo_t * info, void * context)
    {
        
        if(signum == SIGIO)
            printf("SIGIO   signal: %d\n", signum);
        else if(signum == SIGUSR1)
            printf("SIGUSR1   signal: %d\n", signum);
        else
            printf("error\n");
        
        if(context)
        {
        
            printf("content: %d\n", info->si_int);
            printf("content: %d\n", info->si_value.sival_int);
        }
    }
    
    int main(void)
    {
        
        //int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
        struct sigaction act;
        
        /*
         struct sigaction {
         void     (*sa_handler)(int);
         void     (*sa_sigaction)(int, siginfo_t *, void *);
         sigset_t   sa_mask;
         int        sa_flags;
         };
         */
        act.sa_sigaction = handler;
        act.sa_flags = SA_SIGINFO;
        
        sigaction(SIGIO, &act, NULL);
        sigaction(SIGUSR1, &act, NULL);
        for(;;)
        {
        
            sleep(10000);
        }
        return 0;
    }

发送端代码：

#include <sys/types.h>
    #include <signal.h>
    #include<stdio.h>
    #include <unistd.h>
    
    
    int main(int argc, char** argv)
    {
        
        if(4 != argc)
        {
        
            printf("[Arguments ERROR!]\n");
            printf("\tUsage:\n");
            printf("\t\t%s <Target_PID> <Signal_Number> <content>\n", argv[0]);
            return -1;
        }
        int pid = atoi(argv[1]);
        int sig = atoi(argv[2]);
    
        if(pid > 0 && sig > 0)
        {
        
            //int sigqueue(pid_t pid, int sig, const union sigval value);
            union sigval val;
            val.sival_int = atoi(argv[3]);
            printf("send: %d\n", atoi(argv[3]));
            sigqueue(pid, sig, val);
        }
        else
        {
        
            printf("Target_PID or Signal_Number MUST bigger than 0!\n");
        }
        
        return 0;
    }

运行结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 1]

**4.信号量：**

**4.1.信号量概述：**

\*\*信号量（semaphore）：\*\*与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。

**信号量生活场景**：

去一个房间里嫖娼，一把钥匙(信号量)，房间(临界资源)  
临界资源：一次只允许一个进程(人)使用的资源

**特点**：对共享内存(美少女)进行上锁，信号量是钥匙

**同步和互斥：**

**补充：**

> **同步：**  
> 是指在不同任务之间的若干个程序片段，他们的运行必须  
> 严格按照规定的某种顺序来运行，这种顺序依赖于要完成任  
> 务的特点  
> 场景：多个进程在运行时需要协同步调，按预定的顺序  
> 执行，比如A任务依赖B任务产生的数据  
> **互斥：**  
> 场景：一个公共资源同时只能被一个进程使用

信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。P操作：拿锁 v操作：放回锁

每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。

支持信号量组。

**4.2. 信号量编程实现：**

最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，叫做二值信号量，而可以取多个正整数的信号量，叫做通用信号量

Linux下的信号量函数，都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。

函数原型：

#include <sys/sem.h>
    // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
    int semget(key_t key, int num_sems, int sem_flags);
    // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
    int semop(int semid, struct sembuf semoparray[], size_t numops);
    // 控制信号量的相关信息
    int semctl(int semid, int sem_num, int cmd, ...);

当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num\_sems），通常为1； 如果是引用一个现有的集合，则将num\_sems指定为 0 。

在semop函数中，sembuf结构的定义如下：

struct sembuf
    {
        
        short sem_num; // 信号量组中对应的序号，0～sem_nums-1
        short sem_op;  // 信号量值在一次操作中的改变量
        short sem_flg; // IPC_NOWAIT, SEM_UNDO
    }

其中 sem\_op 是一次操作中的信号量的改变量：

> 若sem\_op > 0，表示进程释放相应的资源数，将 sem\_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。

> 若sem\_op < 0，请求 sem\_op 的绝对值的资源。  
> 如果相应的资源数可以满足请求，则将该信号量的值减去sem\_op的绝对值，函数成功返回。  
> 当相应的资源数不能满足请求时，这个操作与sem\_flg有关。  
> sem\_flg 指定IPC\_NOWAIT，则semop函数出错返回EAGAIN。  
> sem\_flg 没有指定IPC\_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：  
> 当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem\_op的绝对值。成功返回；  
> 此信号量被删除，函数smeop出错返回EIDRM；  
> 进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR

> 若sem\_op == 0，进程阻塞直到信号量的相应值为0：  
> 当信号量已经为0，函数立即返回。  
> 如果信号量的值不为0，则依据sem\_flg决定函数动作：  
> sem\_flg指定IPC\_NOWAIT，则出错返回EAGAIN。  
> sem\_flg没有指定IPC\_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：  
> 信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；  
> 此信号量被删除，函数smeop出错返回EIDRM；  
> 进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR

在semctl函数中的命令有多种，这里就说两个常用的：

> SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。  
> IPC\_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

演示代码：

#include<stdio.h>
    #include<stdlib.h>
    #include<sys/sem.h>
    // 联合体，用于semctl初始化
    union semun
    {
        
        int              val; /*for SETVAL*/
        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操作:
    //    若信号量值为1，获取资源并将信号量值-1
    //    若信号量值为0，进程挂起等待
    int sem_p(int sem_id)
    {
        
        struct sembuf sbuf;
        sbuf.sem_num = 0; /*序号*/
        sbuf.sem_op = -1; /*P操作*/
        sbuf.sem_flg = SEM_UNDO;
        if(semop(sem_id, &sbuf, 1) == -1)
        {
        
            perror("P operation Error");
            return -1;
        }
        return 0;
    }
    // V操作：
    //    释放资源并将信号量值+1
    //    如果有进程正在挂起等待，则唤醒它们
    int sem_v(int sem_id)
    {
        
        struct sembuf sbuf;
        sbuf.sem_num = 0; /*序号*/
        sbuf.sem_op = 1;  /*V操作*/
        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 main()
    {
        
        int sem_id;  // 信号量集ID
        key_t key;
        pid_t pid;
        // 获取key值
        if((key = ftok(".", 'z')) < 0)
        {
        
            perror("ftok error");
            exit(1);
        }
        // 创建信号量集，其中只有一个信号量
        if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
        {
        
            perror("semget error");
            exit(1);
        }
        // 初始化：初值设为0资源被占用
        init_sem(sem_id, 0);
        if((pid = fork()) == -1)
            perror("Fork Error");
        else if(pid == 0) /*子进程*/
        {
        
            sleep(2);
            printf("Process child: pid=%d\n", getpid());
            sem_v(sem_id);  /*释放资源*/
        }
        else  /*父进程*/
        {
        
            sem_p(sem_id);   /*等待资源*/
            printf("Process father: pid=%d\n", getpid());
            sem_v(sem_id);   /*释放资源*/
            del_sem(sem_id); /*删除信号量集*/
        }
        return 0;
    }

上面的例子如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。

运行结果：  
![在这里插入图片描述][20201014194951884.png_pic_center]

**总：进程通信综合实例：**

下面这个例子，使用了【共享内存+信号量+消息队列】的组合来实现服务器进程与客户进程间的通信。

> 共享内存用来传递数据；  
> 信号量用来同步；  
> 消息队列用来 在客户端修改了共享内存后 通知服务器读取。

演示代码：

server.c

#include<stdio.h>
    #include<stdlib.h>
    #include<sys/shm.h>  // shared memory
    #include<sys/sem.h>  // semaphore
    #include<sys/msg.h>  // message queue
    #include<string.h>   // memcpy
    // 消息队列结构
    struct msg_form {
        
        long mtype;
        char mtext;
    };
    // 联合体，用于semctl初始化
    union semun
    {
        
        int              val; /*for SETVAL*/
        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操作:
    //  若信号量值为1，获取资源并将信号量值-1
    //  若信号量值为0，进程挂起等待
    int sem_p(int sem_id)
    {
        
        struct sembuf sbuf;
        sbuf.sem_num = 0; /*序号*/
        sbuf.sem_op = -1; /*P操作*/
        sbuf.sem_flg = SEM_UNDO;
        if(semop(sem_id, &sbuf, 1) == -1)
        {
        
            perror("P operation Error");
            return -1;
        }
        return 0;
    }
    // V操作：
    //  释放资源并将信号量值+1
    //  如果有进程正在挂起等待，则唤醒它们
    int sem_v(int sem_id)
    {
        
        struct sembuf sbuf;
        sbuf.sem_num = 0; /*序号*/
        sbuf.sem_op = 1;  /*V操作*/
        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 creat_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;
        char data[] = "this is server";
        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 = creat_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;
    }

client.c

#include<stdio.h>
    #include<stdlib.h>
    #include<sys/shm.h>  // shared memory
    #include<sys/sem.h>  // semaphore
    #include<sys/msg.h>  // message queue
    #include<string.h>   // memcpy
    // 消息队列结构
    struct msg_form {
        
        long mtype;
        char mtext;
    };
    // 联合体，用于semctl初始化
    union semun
    {
        
        int              val; /*for SETVAL*/
        struct semid_ds *buf;
        unsigned short  *array;
    };
    // P操作:
    //  若信号量值为1，获取资源并将信号量值-1
    //  若信号量值为0，进程挂起等待
    int sem_p(int sem_id)
    {
        
        struct sembuf sbuf;
        sbuf.sem_num = 0; /*序号*/
        sbuf.sem_op = -1; /*P操作*/
        sbuf.sem_flg = SEM_UNDO;
        if(semop(sem_id, &sbuf, 1) == -1)
        {
        
            perror("P operation Error");
            return -1;
        }
        return 0;
    }
    // V操作：
    //  释放资源并将信号量值+1
    //  如果有进程正在挂起等待，则唤醒它们
    int sem_v(int sem_id)
    {
        
        struct sembuf sbuf;
        sbuf.sem_num = 0; /*序号*/
        sbuf.sem_op = 1;  /*V操作*/
        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;
    }

注意：当scanf()输入字符或字符串时，缓冲区中遗留下了\\n，所以每次输入操作后都需要清空标准输入的缓冲区。但是由于 gcc 编译器不支持fflush(stdin)（它只是标准C的扩展），所以我们使用了替代方案：

while((c=getchar())!='\n' && c!=EOF);

运行结果：

客户机请求：  
![在这里插入图片描述][2020101420081686.png_pic_center]  
服务器回应：  
![在这里插入图片描述][20201014200844625.png_pic_center]

[20201013194528178.png_pic_center]: /images/20221123/ff9235d817f14af0823f76a56853a172.png
[20201013195405772.png_pic_center]: /images/20221123/6230f073a6bd4926a97c98751f999e91.png
[20201013203327581.png_pic_center]: /images/20221123/7654d46b3bad4e63a1ca32b19e066727.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/09790e6f9eb34ba1843aaf54cc82efc6.png
[20201014162739776.png_pic_center]: /images/20221123/f88b8d61550e445bbc8c6e34b45fdc54.png
[20201014162819305.png_pic_center]: /images/20221123/ab14a3a57c78458d9bfc583615635cc4.png
[20201014164126236.png_pic_center]: /images/20221123/e9dd785840ce45b68465cd7d9076aa85.png
[20201014164150833.png_pic_center]: /images/20221123/3cfa01e57d814251b0e40430b6c82f9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/5c8e8b0bbaf5458781d33395135a5855.png
[20201014194951884.png_pic_center]: /images/20221123/c5eed71ec061484daa7527f95f74b6fa.png
[2020101420081686.png_pic_center]: /images/20221123/25e847bda2de49a5bf7d771c36355f9b.png
[20201014200844625.png_pic_center]: /images/20221123/cc96c23ad2d646518895166687e626ef.png