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

消息队列,共享内存,信号,信号量

1.消息队列:

1.1消息队列的通信原理:

消息队列:

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

特点:

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

函数原型:

#include 
// 创建或打开消息队列:成功返回队列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  
#include  
#include 
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 
#include 
#include 
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 
#include 
#include 
#include 
#include 
//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 
#include 
#include 
#include 
#include 
//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;
}

运行结果:

在这里插入图片描述
案例演示:

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

msg_server.c:

#include 
#include 
#include 
// 用于创建一个唯一的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 
#include 
#include 
// 用于创建一个唯一的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;
}

运行结果:
在这里插入图片描述
1.3键值生成及消息队列移除:

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

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

函数原型:

#include 
#include 
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 
#include 
#include 
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 
// 创建或获取一个共享内存:成功返回共享内存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 
#include  
int shmget(key_t key, size_t size, int shmflg);

连接共享内存:

#include  
#include 
void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);

断开连接:

#include 
#include 
void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);

关闭共享内存:

#include 
#include 
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 
#include 
#include 
#include 
#include 
#include 
//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 
#include 
#include 
#include 
#include 
#include 
//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;
}

运行结果:

在这里插入图片描述
注意:在./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 可查看所有的信号
Linux进程通信2:消息队列,共享内存,信号,信号量.(含:综合实例:实现服务器进程和客户进程通信)_第1张图片
其中:

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 
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
#include
#include 
//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发送信号:
Linux进程通信2:消息队列,共享内存,信号,信号量.(含:综合实例:实现服务器进程和客户进程通信)_第2张图片
程序接收到的信号处理结果:
Linux进程通信2:消息队列,共享内存,信号,信号量.(含:综合实例:实现服务器进程和客户进程通信)_第3张图片
简单的总结一下,我们通过 signal 函数注册一个信号处理函数,分别注册了两个信号(SIGIO 和 SIGUSER1);随后主程序就一直“长眠”了。

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

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

那么,已经可以设置信号处理函数了,信号的处理还有两种状态,分别是默认处理和忽略,这两种设置很简单,只需要将 handler 设置为 SIG_IGN(忽略信号)或 SIG_DFL(默认动作)即可

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

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

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

信号发送函数——入门版

kill 的函数原型:

#include 
#include 
int kill(pid_t pid, int sig);

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

演示代码:kill.c

#include 
#include 
#include
#include 
#include 
int main(int argc, char** argv)
{
    if(3 != argc)
    {
        printf("[Arguments ERROR!]\n");
        printf("\tUsage:\n");
        printf("\t\t%s  \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;
}

运行结果:

发送信号:
Linux进程通信2:消息队列,共享内存,信号,信号量.(含:综合实例:实现服务器进程和客户进程通信)_第4张图片
接收信号:
在这里插入图片描述
总结一下:

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

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

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

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

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

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

sigaction 的函数原型:

#include 
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
#include
#include 

//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 
#include 
#include
#include 


int main(int argc, char** argv)
{
    if(4 != argc)
    {
        printf("[Arguments ERROR!]\n");
        printf("\tUsage:\n");
        printf("\t\t%s   \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;
}

运行结果:
Linux进程通信2:消息队列,共享内存,信号,信号量.(含:综合实例:实现服务器进程和客户进程通信)_第5张图片

4.信号量:

4.1.信号量概述:

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

信号量生活场景

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

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

同步和互斥:

补充:

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

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

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

支持信号量组。

4.2. 信号量编程实现:

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

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

函数原型:

#include 
// 创建或获取一个信号量组:若成功返回信号量集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
#include
#include
// 联合体,用于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;
}

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

运行结果:
在这里插入图片描述

总:进程通信综合实例

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

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

演示代码:

server.c

#include
#include
#include  // shared memory
#include  // semaphore
#include  // message queue
#include   // 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
#include
#include  // shared memory
#include  // semaphore
#include  // message queue
#include   // 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);

运行结果:

客户机请求:
Linux进程通信2:消息队列,共享内存,信号,信号量.(含:综合实例:实现服务器进程和客户进程通信)_第6张图片
服务器回应:
在这里插入图片描述

你可能感兴趣的:(linux系统编程,linux,多进程,消息队列,信号量,共享内存)