【Linux系统编程】进程间通信

进程间通信

1.概念

进程间通信（IPC，InterProcess Communication)是指在不同进程之间传播或交换信息。

优点：

数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件
进程控制：有些进程希望完全控制另一个进程的执行(如Debug进程)，该控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。

IPC通信原理 ：每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信机制。通常的做法是消息发送方将要发送的数据存放在内存缓存区中，通过系统调用进入内核态。然后内核程序在内核空间分配内存，开辟一块内核缓存区，内核空间调用 copy_from_user() 函数将数据从用户空间的内存缓存区拷贝到内核空间的内核缓存区中。同样的，接收方进程在接收数据时在自己的用户空间开辟一块内存缓存区，然后内核程序调用 copy_to_user() 函数将数据从内核缓存区拷贝到接收进程的用户空间内存缓存区。这样数据发送方进程和数据接收方进程就完成了一次数据传输，我们称完成了一次进程间通信。

IPC的方式通常有linux下的 管道（Streams)（包括无名管道和命名管道）、消息队列、信号量、信号、共享存储、Socket等。其中 Socket和Streams支持不同主机上的两个进程IPC，以及android下的Binder

2.管道

管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。

1.特点

它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

2.原型

c 复制代码

#include <unistd.h>
int pipe(int fd[2]);    // 返回值：若成功返回0，失败返回-1

当一个管道建立时，调用pipe函数在内核中开辟一块缓冲区用于通信，它会创建两个文件描述符：

fd[0]为读而打开，fd[1]为写而打开。

要关闭管道只需将这两个文件描述符关闭即可。如下图：

读fd[0],把fd[1]关闭，写fd[1],把fd[0]关闭。注意：管道的特性:管道里没有数据会阻塞

3.代码示例

单个进程中的管道几乎没有任何用处。所以，通常调用 pipe 的进程接着调用 fork，这样就创建了父进程与子进程之间的 IPC 通道。如下图所示：

若要数据流从父进程流向子进程，则关闭父进程的读端（fd[0]）与子进程的写端（fd[1]）；反之，则可以使数据流从子进程流向父进程。

c 复制代码

//读0写1，父进程写数据到文件里面，子进程读出来
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> 
//int pipe(int pipefd[2]);
//ssize_t write(int fd, const void *buf, size_t count);
//ssize_t read(int fd, void *buf, size_t count);
int main()
{
    int fd[2];
    int pid;
    char buf[128];

    if(pipe(fd) == -1){
        printf("creat pipe fail\n");
    }
    pid = fork();
    if(pid < 0 ){
        printf("creat child fail\n");
    }
    else if(pid > 0){       
        printf("this is father\n");
        close(fd[0]);//写1，写的时候把读0关闭
        write(fd[1],"hello from father",strlen("hello from father"));//在子进程没开始前，这句话并没有被打印出来

        wait();
    }
    else{
        sleep(3);//让父进程先运行
        printf("this is child\n");
        close(fd[1]);//读0，读的时候同样把写1关闭
        read(fd[0],buf,128);
        printf("read = %s \n",buf);

        exit(0);
    }

    return 0;
}

运行结果：

3.FIFO

FIFO，也称为命名管道，它是一种文件类型。

1.特点

FIFO可以在无关的进程之间交换数据，与无名管道不同。
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

2.原型

c 复制代码

#include <sys/stat.h>
// 返回值：成功返回0，出错返回-1
int mkfifo(const char *pathname, mode_t mode);

其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。

当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。

这句话什么意思呢？就是在一个读数据的进程，在写数据进程运行之前，读数据的这个进程会一直阻塞在这里，下面代码会演示

若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

写数据还没有运行前，读数据不会被阻塞，嘎嘎刷

3.代码示例

FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且"先进先出"。

read.c

c 复制代码

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
 
//ssize_t read(int fd, void *buf, size_t count);
//int mkfifo(const char *pathname, mode_t mode);
//int open(const char *pathname, int flags);
 
int main()
{
    int fd;
    char buf[128] = {0};
//创建失败返回-1，已经存在也会报错返回EEXIST
    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,contxt = %s \n",n_read,buf);
    }
    close(fd);
    return 0;
}

write.c

c 复制代码

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
 
//ssize_t write(int fd, const void *buf, size_t count);
//int mkfifo(const char *pathname, mode_t mode);
//int open(const char *pathname, int flags);

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

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

    while(1){
        write(fd,str,strlen(str));
        sleep(1);//1秒写一次
    }
    close(fd);
    return 0;
}

在写运行之前会阻塞在这里：

对应上面这句话：若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。

运行write.c之后：

每一秒会接收一次

4.消息队列

1.特点

消息队列是消息的链表,具有特定的格式,存放在内存中并由消息队列标识符标识。

一个消息队列由一个标识符（即队列ID）来标识

消息队列允许一个或多个进程向它写入与读取消息。
管道和命名管道都是通信数据都是先进先出的原则。

消息对列提供了一个进程向另一个进程发送一块数据块的通信方法，注意，是以块为基本单位，前面的管道是以字节流为基本单位。

消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取.比FIFO更有优势。

大概思路是：AB两个进程，A进程 1.打开/创建消息队列 2.写数据到那个队列 B进程 1.打开/创建消息队列 2.读那个队列数据

2.原型

c 复制代码

//1.头文件
#include <sys/msg.h>
#include <sys/types.h>
#include <sys/ipc.h>
//创建或打开消息队列：成功返回队列 ID ，失败返回 -1    
int msgget(key_t key, int msgflg);
//添加消息：成功返回 0 ，失败返回 -1 
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//读取信息：成功返回消息数据的长度，失败返回 -1
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
//控制消息队列:成功返回 0 ，失败返回 -1 
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

1.key_t ftok(char * pathname, char proj)

c 复制代码

//返回与路径pathname相对应的一个键值(key_t key)
key_t ftok(char *pathname, char proj)；

  1.pathname：文件名（含路径）,通常设置为当前目录"." 比如projid为'a',则为"./a"文件
  2.projid：项目ID，必须为非0整数（0-255）.

2.int msgget(key_t key, int flag);

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

如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。
key参数为IPC_PRIVATE。

c 复制代码

//创建或打开消息队列：成功返回队列ID，失败返回-1
int msgget(key_t key, int flag);  

 flag:
   IPC_CREAT:创建新的消息队列。
   IPC_EXCL:与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。
   IPC_NOWAIT:读写消息队列要求无法满足时，不阻塞

3.int msgsnd(int msqid, struct msgbuf * msgp, size_t msgsz, int msgflag);

c 复制代码

// 添加消息：成功返回0，失败返回-1
int msgsnd(int msqid,  struct msgbuf *msgp,  size_t msgsz,  int msgflag);

 1. msqid:已打开的消息队列id ，由msgget()函数返回   
 2. msgp:存放消息的结构体指针。
 消息结构msgbuf为:
 struct msgbuf
 {
    long mtype;//消息类型
    char mtext[1];//消息正文，消息数据的首地址，这个数据的最大长度为8012吧，又可把他看成是一个结构，也有类型和数据，recv时解析即可。
  }
 3. msgsz:消息数据的长度。
 4. msgflag:函数的控制属性。
      IPC_NOWAIT: 指明在消息队列没有足够空间容纳要发送的消息时，msgsnd立即返回。
      0:msgsnd调用阻塞直到条件满足为止.（一般选这个）

4.int msgrcv(int msqid, struct msgbuf * msgp, size_t msgsz, long msgtype, int msgflag);

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

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

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

在成功地读取了一条消息以后，队列中的这条消息将被删除。

c 复制代码

//读取消息：成功返回消息数据的长度，失败返回-1
int msgrcv(int msqid,  struct msgbuf *msgp,  size_t msgsz,  long msgtype,  int msgflag);

1. msqid:已打开的消息队列id
2. msgp:存放消息的结构体指针。msgp->mtype与第四个参数是相同的。
3. msgsz:消息的字节数，指定mtext的大小。
4. msgtype:消息类型，消息类型 mtype的值。如果为0，则接受该队列中的第一条信息，如果小于0，则接受小于该值的绝对值的消息类型，如果大于0，接受指定类型的消息，即该值消息。
5. msgflag:函数的控制属性。
    msgflag:
        MSG_NOERROR:若返回的消息比nbytes字节多,则消息就会截短到nbytes字节,且不通知消息发送进程.
        IPC_NOWAIT:调用进程会立即返回.若没有收到消息则返回-1.
        0:msgrcv调用阻塞直到条件满足为止.//用此居多

5.int msgctl(int msqid, int cmd, struct msqid_ds * buf);

c 复制代码

// 控制消息队列：成功返回0，失败返回-1
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

 msqid:消息队列ID，消息队列标识符，该值为msgget创建消息队列的返回值。
 cmd:
    IPC_STAT:将msqid相关的数据结构中各个元素的当前值存入到由buf指向的结构中.
    IPC_SET:将msqid相关的数据结构中的元素设置为由buf指向的结构中的对应值.
    IPC_RMID:删除由msqid指示的消息队列,将它从系统中删除并破坏相关数据结构.（一般用此居多，消息队列会一直存在，所以需要手动删除）
 buf:消息队列缓冲区  一般给NULL

3.代码示例

下面写了一个简单的使用消息队列进行IPC的例子，相较于FIFO的半双工，消息队列具有通信双方互相收发的全双工特点。

两个程序之间进行互相收发。

send.c

c 复制代码

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<string.h>

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

int main()
{
	struct msgbuf sendBuf={888,"this is msgged from que"};
    struct msgbuf readBuf;
//1.生成一个键值
    key_t key;
    key=ftok(".",1);
//2.打印键值
    printf("key=%d\n",key);
//3.创建/打开一个消息队列，加以权限
	int msgId=msgget(key,IPC_CREAT|0777);
	if(msgId==-1)
	{
		perror("why:");
	}
	while(1)
	{
	//4.发送消息，消息内容+指定类型888，消息长度，阻塞发送
		msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
        sleep(1);
		printf("write success\n");
     //5.接收消息，存到哪里，消息长度，接收988类型的消息，阻塞接收
        msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),988,0);
        sleep(1);
        printf("read from que:%s\n",readBuf.mtext);
	}
//6.删除相对应的队列
    msgctl(msgId,IPC_RMID,NULL);        
	return 0;
}

read.c

c 复制代码

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<string.h>

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

int main()
{
	struct msgbuf readBuf;
    struct msgbuf sendBuf={988,"this is msgged father"};
//1.同上，获取键值
    key_t key;
    key=ftok(".",1);//"."代表当前文件夹
    printf("key=%d\n",key);
//2.打开消息队列及权限
	int msgId=msgget(key,IPC_CREAT|0777);
	if(msgId==-1)
	{
		perror("why:");
	}

	while(1)
	{//3.接收消息队列，存到哪里，大小，只接收888消息类型，阻塞
		msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);
        sleep(1);
		printf("read from que:%s\n",readBuf.mtext); 
//4.发送消息，发送什么，长度，阻塞
        msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
        sleep(1);
        printf("write success\n");               
	}
//5.删除消息队列
    msgctl(msgId,IPC_RMID,NULL);
	return 0;
}

5.信号

信号是一种事件通知机制，当接收到该信号的进程会执行相应的操作。

对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c 来中断程序，会通过信号机制停止一个程序。（按下Ctrl+c，向运行的程序发送一个信号，终止运行）

1.信号的名字和编号

每个信号都有一个名字和编号，这些名字都以"SIG"开头，例如"SIGIO "、"SIGCHLD"等等。

信号定义在signal.h头文件中，信号名都定义为正整数。

具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0有特殊的应用。

2 .信号的处理

信号的处理有三种方法，分别是：忽略、捕捉和默认动作

忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是 SIGKILL和SIGSTOP）。因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的的进程，显然是内核设计者不希望看到的场景。++(忽略：来了一个信号，我不管这个信号)++
捕捉信号，需要告诉内核，用户希望如何处理某一种信号，说白了就是写一个信号处理函数，然后将这个函数告诉内核。当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号的处理。++（捕捉：跟单片机中断很像，收到一个中断信号，然后调用中断处理函数来干些什么事情。对于这个"处理函数"，在信号这里是需要先注册出来的）++
系统默认动作，对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。
具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。在此，我就不详细展开了，需要查看的，可以自行查看。也可以参考《UNIX 环境高级编程（第三部）》的 P251------P256中间对于每个信号有详细的说明

那么信号如何使用呢？

其实对于常用的 kill 命令就是一个发送信号的工具，kill -9 PID来杀死进程。

比如，我在后台运行了一个死循环程序，通过 ps -aux|grep a.out 命令可以查看他的 PID，通过 kill -9 来发送了一个终止进程的信号来结束了程序进程。如果查看信号编号和名称，可以发现9对应的是 9) SIGKILL，正是杀死该进程的信号。而以下的执行过程实际也就是执行了9号信号的默认动作------杀死进程。（相应的，用数字9和SIGKLL效果一样）

3.函数原型

	入门版	高级版
信号处理函数的注册	函数 `signal`	函数 `sigaction`
信号处理发送函数	kill	sigqueue

入门版

对于信号来说，最大的意义不是为了杀死进程，而是实现一些异步通讯的手段，那么如何来自定义信号的处理函数呢？

1.sigal函数

c 复制代码

#include <signal.h>
//1.真实处理信号的函数
typedef void (*sighandler_t)(int); 

中断函数的原型中，有一个参数是 int 类型，显然也是信号产生的类型，方便使用一个函数来处理多个信号
//2.注册函数
sighandler_t signal(int signum, sighandler_t handler);

signum:显然是信号的编号
handler:中断函数的指针

捕捉信号（自定义函数）示例代码1：

这个自定义信号函数必须是信号列表里的（kill -l），这些信号都有默认动作，只不过我们写了个自己的函数，当信号再次发生时，不再执行默认动作，而是执行我们自己的函数

c 复制代码

//ctrl+c对应着-2 SIGINT信号
//执行此信号，我们会中断掉这个死循环，下面我们来自定义此信号，
#include <stdio.h>
#include <signal.h>

void handler(int signum)
{
    printf("signum is %d\n",signum);
    printf("never over\n");
}
int main()
{
    signal(SIGINT,handler);
    while(1);
    return 0;
}

信号的处理还有两种状态，分别是默认动作和忽略。

这两种设置很简单，只需要将 handler 设置为 SIG_IGN（忽略信号）或 SIG_DFL（默认动作）即可

c 复制代码

#include <signal.h>
#include <stdio.h>
 
//       typedef void (*sighandler_t)(int);
//       sighandler_t signal(int signum, sighandler_t handler);
int main()
{
        signal(SIGINT,SIG_IGN);    //参数1：注册(接收)crtl+c这个信号，参数2：宏（忽略）
        signal(SIGKILL,SIG_IGN);
        signal(SIGUSR1,SIG_IGN); 
        while(1);
        return 0;
}

2.kill函数

c 复制代码

//信号发送函数，1.发给谁？一个进程，2.怎么识别？进程ID号 3.发送什么信号？signal
#include <sys/types.h>
#include <signal.h>
 
int kill(pid_t pid, int sig);
pid_t pid：进程的PID号
int sig：要发送的信号

注：atoi = ascall to int 意思是将字符串转化为整型数

c 复制代码

#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
 
//int kill(pid_t pid, int sig);
 
int main(int argc,char **argv)
{
    int signum;
    int pid;

    signum = atoi(argv[1]);    //atoi() 将argv[i]的字符串，转换为 整型数 
    pid = atoi(argv[2]);

    printf("signum = %d , pid = %d \n",signum,pid);
    //int kill(pid_t pid, int sig);
    kill(pid,signum);
    printf("send siganal ok\n");
    return 0;
}

想一下，这个死循环我们怎么退出？kill -9 pid （这里的kill是发送信号的意思，那么现在我们不通过Linux指令来操作了），通过程序里面的信号发送函数kill，来杀死这个死循环进程。

c 复制代码

//我们发现，这个-9 SIGKILL是改不动的，信号并没有我们想象的那么脆弱
#include <signal.h>
#include <stdio.h>

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

    while(1);
    return 0;
}

除了kill函数还可以用sprintf()配合system()函数来做到同样的信号处理发送

c 复制代码

#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
 
//int kill(pid_t pid, int sig);
 
int main(int argc,char **argv)
{
        int signum;
        int pid;
        char cmd[128] = {0};
 
        signum = atoi(argv[1]);    //atoi() 将argv[i]的字符串，转换为 整型数
        pid = atoi(argv[2]);
 
        printf("signum = %d , pid = %d \n",signum,pid);
//      kill(pid,signum);       
        sprintf(cmd,"kill -%d %d",signum,pid);
        system(cmd);

        printf("send siganal ok\n");
        return 0;
}

高级版

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

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

1.sigaction信号注册函数

c 复制代码

#include <signal.h>

//sigaction 是一个系统调用
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

signum:注册的信号的编号
act:如果不为空说明需要对该信号有新的配置
oldact：如果不为空，那么可以对之前的信号配置进行备份，以方便之后进行恢复(一般为NULL，不管就行了)
    
//回调函数句柄sa_handler、sa_sigaction只能任选其一

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

c 复制代码

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表示能够接受数据
 };
struct sigaction结构体中的 sa_mask 成员，设置在其的信号集中的信号，会在捕捉函数调用前设置为阻塞，
    并在捕捉函数返回时恢复默认原有设置。这样的目的是，在调用信号处理函数时，就可以阻塞默写信号了。
    在信号处理函数被调用时，操作系统会建立新的信号阻塞字，包括正在被递送的信号。
    因此，可以保证在处理一个给定信号时，如果这个种信号再次发生，那么他会被阻塞到对之前一个信号的处理结束为止。

sigaction 的时效性：当对某一个信号设置了指定的动作的时候，那么，直到再次显式调用 sigaction并改变动作之前都会一直有效。

关于结构体中的 flag 属性的详细配置，在此不做详细的说明了，只说明其中一点。如果设置为 SA_SIGINFO 属性时，说明了信号处理程序带有附加信息，也就是会调用 sa_sigaction 这个函数指针所指向的信号处理函数。否则，系统会默认使用 sa_handler 所指向的信号处理函数。在此，还要特别说明一下，sa_sigaction 和 sa_handler 使用的是同一块内存空间，相当于 union，所以只能设置其中的一个，不能两个都同时设置。

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

c 复制代码

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

2.sigqueue信号发送函数

c 复制代码

#include <signal.h>
int sigqueue(pid_t pid, int sig, const union sigval value);
union sigval {
   int   sival_int;
   void *sival_ptr;
 };

使用 sigaction 函数安装信号处理程序时，制定了 SA_SIGINFO 的标志。

sigaction 结构体中的 sa_sigaction 成员提供了信号捕捉函数。如果实现的时 sa_handler 成员，那么将无法获取额外携带的数据。

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

sigqueue 函数不但可以发送额外的数据，还可以让信号进行排队（操作系统必须实现了 POSIX.1的实时扩展），对于设置了阻塞的信号，使用 sigqueue 发送多个同一信号，在解除阻塞时，接受者会接收到发送的信号队列中的信号，而不是直接收到一次。

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

接收端：

c 复制代码

#include <signal.h>
#include <stdio.h>
 
//       int sigaction(int signum, const struct sigaction *act,
//              struct sigaction *oldact);
 
//void     (*sa_sigaction)(int, siginfo_t *, void *);
 
void handler(int signum,siginfo_t *info,void *context)    //参数1：信号值，参数2：内容，参数3：是否为NULL决定有没有内容
{
        printf("get signum %d\n",signum);
 
        if(context != NULL){                              //非空，代表有内容
                printf("get data = %d\n",info->si_int);
                printf("get data = %d\n",info->si_value.sival_int);
                printf("from = %d\n",info->si_pid);
        }
}
 
int main()
{
        struct sigaction act;
        act.sa_sigaction = handler;      //调用handler函数处理信号
        act.sa_flags = SA_SIGINFO;      //要想接收信号数据，必须指定这个flag 是 SA_SIGINFO  
 
        printf("%d\n",getpid());
 
        sigaction(SIGUSR1,&act,NULL);    //参数1：接收哪个信号，参数2：收到信号后想怎么处理它，参数3：备份原信号的操作。一般设置为NULL，不关心
 
        while(1);
        return 0;
}

发送端：

c 复制代码

#include <stdio.h>
#include <signal.h>
 
//int  sigqueue(pid_t  pid,  int  sig,  const  union  sigval value);
 
int main(int argc,char **argv)
{
        int signum;
        int pid;
 
        printf("%d\n",getpid());
 
        signum = atoi(argv[1]);    //atoi() 将argv[i]的字符串，转换为 整型数
        pid = atoi(argv[2]);
 
        union  sigval value;
        value.sival_int = 100;
    
        sigqueue(pid,signum,value);    //参数1：进程pid，参数2：信号值，参数3：你要发送的信息
 
        printf("done\n");
        return 0;
}

6.信号量

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

场景描述：现在有一个房间，有锁，需要有钥匙才能进去，钥匙在哪里放着？key_t fork

1.特点

信号量用于进程间同步，若要在进程间传递胡数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。（P操作:拿锁。V操作：放回锁）
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减1 ，而且可以加加减任意正整数。
支持信号量组

2.函数原型

二值信号量（Binary Semaphore）：只能取 0 和 1 的变量，是最简单的信号量，这也是信号量最常见的一种形式（垃圾）

**通用信号量：**可以取多个正整数的信号量（一般我们说的信号量指的是这个，也常用这个）

c 复制代码

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
 
//创建或获取一个信号量组，成功会返回信号量集 ID ，失败返回 -1
int semget(key_t key, int nsems, int semflg);
//对信号量组进行操作，改变信号量的值，成功返回 0，失败返回 -1 （用于 PV 操作）
int semop(int semid, struct sembuf *sops, unsigned nsops);    
//控制信号量的相关信息 （用于给信号量初始化）
int semctl(int semid, int semnum, int cmd, ...);

semget函数

创建或获取一个信号量组

c 复制代码

//1.函数原型
int semget(key_t key, int nsems, int semflg);
//2.参数
key:一个整型值对应内核中一个信号量对象，可以自己指定，不同信号量的key值不一样。
    不相关的进程可以通过它访问同一个信号量。程序对所有信号量的访问都是间接的，
    它先提供一个键，再由系统生成一个响应的信号标识符。
(就是一个键值，跟消息队列的key是一个回事)
    
nsems:信号集中信号量的个数

semflg: 由九个权限标志构成，它们的用法和创建文件时使⽤的mode模式标志是一样的
//3.返回值
成功会返回信号量集 ID ，失败返回 -1

semop函数

对信号量组进行操作

c 复制代码

//1.函数原型
int semop(int semid, struct sembuf *sops, unsigned nsops); 
//2.参数
semid:是该信号量的标识码，也就是semget函数的返回值

sops:是个指向一个结构数值的指针
    指向一个结构数组的指针，每个数组元素至少包含以下几个成员： 
    struct sembuf{
        short sem_num; //信号量组中对应的序号,信号量编号，除非使用一组信号量，否则它的取值为0
        short sem_op;  //信号量在一次操作中需要改变的数值。通常用到两个值，-1，也就是p操作，表示拿锁；+1，也就是V操作，表示放回锁。
        short sem_flg; //通过被设置为SEM_UNDO。表示操作系统会跟踪当前进程对这个信号量的修改情况，如果这个进程在没有释放该信号量的情况下终止，操作系统将自动释放该进程持有的信号量，防止其他进程一直处于等待状态。 
    };  
nsops:信号量的个数
//3.返回值
成功返回0；失败返回-1

semctl函数

控制信号量的相关信息

系统调用semctl用来执行在信号量集上的控制操作。这和在消息队列中的系统调用msgctl是十分相似的。但这两个系统调用的参数略有不同。

c 复制代码

//1.函数原型
int semctl(int semid, int semnum, int cmd, ...);
//2.参数
semid： 信号量的标志码(ID)，也就是semget（）函数的返回值;

semnum： 操作信号在信号集中的编号。从0开始。(假如我要操作第一个信号量集，则为0)

cmd： 命令，表示将要进行的操作。
   //参数cmd中可以使用的命令如下：
    ·IPC_STAT 读取一个信号量集的数据结构semid_ds，并将其存储在semun中的buf参数中。
    ·IPC_SET 设置信号量集的数据结构semid_ds中的元素ipc_perm，其值取自semun中的buf参数。
    ·IPC_RMID 将信号量集从内存中删除。
    ·GETALL 用于读取信号量集中的所有信号量的值。
    ·GETNCNT 返回正在等待资源的进程数目。
    ·GETPID 返回最后一个执行semop操作的进程的PID。
    ·GETVAL 返回信号量集中的一个单个的信号量的值。
    ·GETZCNT 返回正在等待完全空闲的资源的进程数目。
    ·SETALL 设置信号量集中的所有的信号量的值。
    ·SETVAL 设置信号量集中的一个单独的信号量的值。【一般用这个】

    此函数具有三个或四个参数，具体取决于cmd。当有四个时，第四个具有union semun类型。
    
		第四个参数：可选。是否使用取决于所请求的命令。如果使用该参数，则其类型是semun。
        union semun{
          int val；                   SETVAL的值
          struct semid_ds *buf;       IPC_STAT，IPC_SET的缓冲区 
          unsigned short *array;      GETALL，SETALL的数组
          struct seminfo __buf;       IPC_INFO的缓冲区（特定于Linux）
        };
        (一般只使用val这个成员，来为信号量赋初值。当信号量值为0时，进程会阻塞运行。)

3.示例代码

c 复制代码

//子进程先运行，把要处理的事情干完后，把锁放进去，之后父进程去拿锁，拿完锁开锁，干完事情之后，放回去锁，然后销毁锁
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>

//int semget(key_t key, int nsems, int semflg);
//int semctl(int semid, int semnum, int cmd, ...);
//int semop(int semid, struct sembuf *sops, unsigned nsops); 
//联合体，用于semctl初始化
union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux-specific) */
};
 
void pGetKey(int id)
{
    struct sembuf set;
    set.sem_num = 0;            //一般默认是 0
    set.sem_op = -1;            //因为我信号量的初始值设置为0，所以这里-1就是取走锁
    set.sem_flg = SEM_UNDO;     //一般是 SEM_UNDO ，大概是表示阻塞等待

    semop(id,&set,1);           //参数2：是个指向⼀一个结构数值的指针
                                //参数3：信号量的个数
    printf("get key\n");
}
 
void pPutBackKey(int id)
{
    struct sembuf set;
    set.sem_num = 0;           //一般默认是 0
    set.sem_op = 1;            //因为我信号量的初始值设置为0，所以这里+1就是有锁
    set.sem_flg = SEM_UNDO;    //一般是 SEM_UNDO ，大概是表示阻塞等待

    semop(id,&set,1); 
    printf("put back the key\n");
}
 
int main()
{
    int semid;
    key_t key;
    key = ftok(".",2);

    //1.获取或创建信号量
    semid =  semget(key,1,IPC_CREAT|0666);  //参数2：信号量集合中有 1 个信号量 
                                            //参数3：0666 是信号量的权限
    union semun initsem;
    //为0的话里面没有锁（这是假设锁已经被拿出去了，需要人来放进去，谁来放？子进程）
    initsem.val = 0;           //一般只使用val这个成员，来为信号量赋初值。为0时，没有钥匙
    //2.初始化信号量    
    semctl(semid,0,SETVAL,initsem);    //参数2：操作第1个信号量集（跟数组一样，从零开始）    
                                       //参数3：SETVAL 设置信号量的初值，此时决定有第四个参数，设置为initsem.
                                       //参数4：是一个联合体。初始化信号量
    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;
}

示例代码优化

c 复制代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdlib.h>
 
//联合体，用于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 操作
// 若信号量值为 1，获取资源并将信号量值 -1
// 若信号量值为 0，进程挂起等待
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 操作
// 释放资源并将信号量值+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 erroe");
		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;
}

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

7.共享内存

一般搭配信号量来用

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

查看共享内存的命令：ipcs -m （在共享内存创建之后，并在断开连接之前，可以加exit(0)退出程序，此时可以用查看命令看到创建的共享内存有哪些）

删除共享内存的命令：ipcs -m id号

1.特点

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

2.函数原型

c 复制代码

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

shmget函数

创建或获取一个共享内存

c 复制代码

//1.函数原型
int shmget(key_t key, size_t size, int shmflg);
//2.参数
1.key： fork函数返回的键值
2.size：共享内存的大小，必须以兆对齐（一兆空间是：1024），如果引用一个已存在的共享内存，则将size指定为0。
3.一般是，创建+权限（可读可写），IPC_CREAT|0600
//3.返回值
成功返回共享内存ID，失败返回 -1

shmat函数

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

c 复制代码

//1函数原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
//2.参数
shmid	：共享内存ID（shmget）
shmaddr ：一般写0，默认是由linux内核自行安排共享内存
shmflg	：一般写0，代表映射的共享内存是可读可写。若是指定了 SHM_RDONLY ，则是以只读的方式。
//3.返回值
成功返回指向共享内存的指针，失败返回 -1

shmdt函数

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

c 复制代码

//1.函数原型
int shmdt(const void *shmaddr);
//2.参数
shmaddr：一般写0，默认是由linux内核自行安排共享内存
//3.返回值
成功返回0，失败返回 -1

shmctl函数

控制共享内存的相关信息，可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作

c 复制代码

//1.函数原型
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
//2.参数
shmid	：共享内存ID（shmget）
cmd		：常用的是IPC_RMID（从系统中删除该共享内存）
buf		：一般写0，因为我们一般不关心共享内存中的数据信息。
//3.返回值
成功返回0，失败返回 -1

3.示例代码

编程思路：

创建/打开共享内存
连接映射共享内存
写入数据 strcpy
断开释放共享内存
干掉共享内存

shm_write.c

c 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <string.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 main()
{
        int shmid;
        char *shmaddr;
 
        key_t key;
        key = ftok(".",1);    //"." 代表当前路径 ，第二个参数随意数字
        
        //创建共享内存
        shmid = shmget(key,1024*4,IPC_CREAT|0600);
        if(shmid == -1){
                printf("creat 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

c 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <string.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 main()
{
        int shmid;
        char *shmaddr;
 
        key_t key;
        key = ftok(".",1);    //"." 代表当前路径 ，第二个参数随意数字
 
        //打开共享内存    
        shmid = shmget(key,1024*4,0);    //以打开方式的时候，第三个参数写0，直接获取，不创建
        if(shmid == -1){
                printf("creat shm fail\n");
                exit(-1);
        }
 
        //连接并映射共享内存
        shmaddr = shmat(shmid,0,0);
        printf("get from shm_write message is : %s",shmaddr);
 
        //断开共享内存连接
        shmdt(shmaddr);
 
        //删除共享内存
        shmctl(shmid,IPC_RMID,0); 
        printf("quit\n");
        return 0;
}

8.综合练习

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

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

server.c

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

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);
    }
 
    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的扩展），所以我们使用了替代方案：

c 复制代码

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