Linux进程间通信

S要早睡

已于 2023-06-11 00:41:11 修改

阅读量460

点赞数 1

文章标签：网络

于 2023-03-29 21:24:32 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_65065429/article/details/129350631

版权

进程间通讯简介

linux进程间通信有父子进程，execl族函数的调用，都是某种意义上的进程间通信，但它们有点残疾，不能建立一个通道，使父子进程拿到自己想要的东西。

单机通信：在同一台pc机上的进程间通信。

多机进程通信：在不同pc机上的进程间通信。

进程间通信介绍

进程间通信(IPC,InterProcess Communication）是指在不同进程之间传播或交换信息。

IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等，其中Socket和Streams不同主机上的两个进程IPC。（记住、需要背）

一、管道

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

1、特点：

1.它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。

2.它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）

3.它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write等函数。但它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。（只有在建立通讯的时候管道才存在）

原型：

#include <unistd.h>
int pipe(int fd[2]);        返回值：若成功返回0，失败则返回-1
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端

               #include<stdio.h>
#include<string.h>
#include<unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include<stdlib.h>

int main()
{
        int fd[2];
        int pid;
        char buf[128]={0};
        if(pipe(fd)==-1){
                printf("created pipe failed\n");
                }
        pid = fork();
        if(pid == -1){
                printf("piped error\n");
                }
        else if(pid >0){
                sleep(2);
                printf("this is father\n");
                close(fd[1]);
                read(fd[0],buf,128);
                wait(NULL);
                printf("contest:%s",buf);
                }
        else{
                printf("this is child\n");
                close(fd[0]);
                write(fd[1],"hello from child\n",strlen("hello from child"));
                exit(0);
                }
                
        return 0;
}

关于read知识点：fork后，不知道是子进程先运行还是父进程先运行，但read读不到信息时，会产生阻塞，会等子程序写完再运行。

二、FIFO（命名管道）

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

1、特点

1.FIFO可以在无关的进程之间交换数据，与无名管道不同。

2.FIFO有路经名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

2、原型

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

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

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

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

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

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
int main()
{
        if((mkfifo("./file1",0600)==-1)&&errno!=EEXIST){
                printf("mkfifo error\n");
                perror("why");
        }

        return 0;
}

不会因为创建的文件存在而报错。

读操作：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>

int main()
{
        if((mkfifo("./file1",0600)==-1)&&errno!=EEXIST){
                printf("mkfifo error\n");
                perror("why");
        }
        int fd;
        fd = open("./file1",O_RDONLY);
        if(fd!=-1){
                printf("open file1 success!\n");
        }
        char readbuf[30]={0};
        int nread = read(fd,readbuf,30);
        printf("read %d byte from fifo,contest:%s\n",nread,readbuf);
        close(fd);
        return 0;
}


写操作：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>


int main()
{

        int fd = open("./file1",O_WRONLY);
        if(fd!= -1)
        printf("open file1 success\n");
        char *str="messge from write ";
        write(fd,str,strlen(str));
        close(fd);
        return 0;
}

三、消息队列

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

1、特点

1.消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。

2.消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。

3.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取。

4.与信号量对比：都是以内核对象来确保多进程访问同一个消息队列，信号量进行进程同步控制，消息队列发送实际数据。

2、原型

#include <sys/msg.h>
//创建或打开消息队列：成功返回队列ID，失败返回-1。
int msgget(key_t key,int flag);  
key就是键值，与其他IPC一样。

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


//添加消息：成功返回0，失败返回-1
int msgsnd(int msqid,const void *ptr,size_t size,int flag);   

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

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


//读取消息：成功返回消息数据的长度，失败返回-1
int msgrcv(int msqid,void *ptr,size_t size,long type,int flag);
msqid:已打开的消息队列id
    msgp:存放消息的结构体指针。msgp->mtype与第四个参数是相同的。
    msgsz:消息的字节数，指定mtext的大小。
    msgtype:消息类型，消息类型 mtype的值。如果为0，则接受该队列中的第一条信息，如果小于0，则接受小于该值的绝对值的消息类型，如果大于0，接受指定类型的消息，即该值消息。
    msgflag:函数的控制属性。
    msgflag:
        MSG_NOERROR:若返回的消息比nbytes字节多,则消息就会截短到nbytes字节,且不通知消息发送进程。
        IPC_NOWAIT:调用进程会立即返回.若没有收到消息则返回-1.
        0:msgrcv调用阻塞直到条件满足为止.
在成功地读取了一条消息以后，队列中的这条消息将被删除。
可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。


int msgctl(int msqid,int cmd,struct msqid_qs *buf);
 msqid:消息队列ID，消息队列标识符，该值为msgget创建消息队列的返回值。
 cmd:
    IPC_STAT:将msqid相关的数据结构中各个元素的当前值存入到由buf指向的结构中.
    IPC_SET:将msqid相关的数据结构中的元素设置为由buf指向的结构中的对应值.
    IPC_RMID:删除由msqid指示的消息队列,将它从系统中删除并破坏相关数据结构.
 buf:消息队列缓冲区

3、消息队列实现的原理

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

内核怎么管理消息队列不关心。

我们关心的是：1、B如何加消息到队列

2、A如何从队列拿到消息

3、如何创建新的队列

4、A、B如何使用同一个队列。


get.c(相当于读)

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<string.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);

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


int main()
{

        struct msgbuf getbuf;
        int getmsg = msgget(0x1234,IPC_CREAT|0777);
        if(getmsg == -1)
        printf("msgget error\n");
        msgrcv(getmsg,&getbuf,sizeof(getbuf.mtext),777,0);
        printf("gmsgID:%d,contest:%s\n",getmsg,getbuf.mtext);

        struct msgbuf sendbuf={（888）777,"6 message from msgget\n"};
        msgsnd(getmsg,&sendbuf,strlen(sendbuf.mtext),0);

        return 0;
}


send.c(相当于写)

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.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);

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


int main()
{

        struct msgbuf sendbuf = {777,"7 message from send"};
        int writemsg = msgget(0x1234,IPC_CREAT|0777);
        if(writemsg == -1)
        printf("msgget error\n");
        msgsnd(writemsg,&sendbuf,strlen(sendbuf.mtext),0);

        struct msgbuf getbuf;
        msgrcv(writemsg,&getbuf,sizeof(getbuf.mtext),777（888）,0);
        printf("gmsgID:%d,contest:%s\n",writemsg,getbuf.mtext);

        return 0;
}

从send.c接收信息时，要用新的type类型，如果用同一个，执行send.c的时候，会造成send和get是同一个函数发送的。

接收的信息来源于send.c，没有送到get.c那里去。

函数ftok

系统建立IPC通讯（消息队列、信号量和共享内存）时必须指定一个ID值。通常情况下，该id值通过ftok函数得到。

#include <sys/types.h>
#include <sys/ipc.h>

//把从pathname导出的信息与id的低序8位组合成一个整数IPC键
key_t ftok(const char *pathname, int proj_id)

pathname：指定的文件，此文件必须存在且可存取（路径名）
proj_id：计划代号（project ID）

返回值：成功：返回key_t值（即IPC 键值）
        出错：-1，错误原因存于error中

ftok(".",1);    //.代表当前文件。


get.c(相当于读)

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<string.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);

struct msgbuf {
               long mtype;       /* message type, must be > 0 */
               char mtext[128];    /* message data */
           };
int main()
{
        key_t key;
        key = ftok(".",2);
        printf("key = %x",key);
        struct msgbuf getbuf;
        int getmsg = msgget(key,IPC_CREAT|0777);
        if(getmsg == -1)
        printf("msgget error\n");
        msgrcv(getmsg,&getbuf,sizeof(getbuf.mtext),777,0);
        printf("gmsgID:%d,contest:%s\n",getmsg,getbuf.mtext);

        struct msgbuf sendbuf={888,"6 message from msgget\n"};
        msgsnd(getmsg,&sendbuf,strlen(sendbuf.mtext),0);
        msgctl(getmsg,IPC_RMID,NULL);     //用完后将所在的队列删除

        return 0;
}


send.c(相当于写)

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include<string.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);

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

int main()
{
        key_t key;
        key = ftok(".",2);    //产生一个键值
        printf("key = %x",key);    

        struct msgbuf sendbuf = {777,"7 message from send"};
        int writemsg = msgget(key,IPC_CREAT|0777);
        if(writemsg == -1)
        printf("msgget error\n");
        msgsnd(writemsg,&sendbuf,strlen(sendbuf.mtext),0);

        struct msgbuf getbuf;
        msgrcv(writemsg,&getbuf,sizeof(getbuf.mtext),888,0);
        printf("gmsgID:%d,contest:%s\n",writemsg,getbuf.mtext);
        msgctl(writemsg,IPC_RMID,NULL);    //用完后将所在的队列删除
        return 0;
}

如何删除一个队列

当我们不断创建新队列，会使内核队列越来越多，最后可能造成卡死，这样我们就要删除使用完的队列。使用msgctl函数。

msgctl(msgId,IPC_RMID,NULL);

msgId:你要删除的队列Id号

共享内存

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

1、特点

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

图片说明：假设A进程有个指针指向共享内存，那么我们直接可以打印该指针的内容来获得共享内存的内容。那么如何把数据写入共享内存呢？运用strcpy函数，把想写入的数据赋值到指针p中。

实现共享内存的思路：图中的a(shmget)、b(shmat)、c、d(shmdt)、e(shmctl)

```
1 #include <sys/shm.h>
// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
2 int shmget(key_t key, size_t size, int flag);    
//size必须是1024的整数倍
// 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1

3 void *shmat(int shm_id, const void *addr, int flag);    
*addr:默认为0，自动连接地址，flag默认为0，意思是可读可写。


 // 断开与共享内存的连接：成功返回0，失败返回-1
4 int shmdt(void *addr); 

 // 控制共享内存的相关信息：成功返回0，失败返回-1
5 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);  
  buf：删除后，可选择打印删除信息
```
当用shmget函数创建一段共享内存时，必须指定其 size(size必须以1024的倍数)；而如果引用一个已存在的共享内存，则将 size 指定为0 。

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

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

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

系统查看共享内存的指令：ipcs -m

删除共享内存(消息队列)的指令：ipcrm -m (共享内存ID号)

shmwrite.c

#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<stdlib.h>
#include<string.h>

int main()
{
        key_t key;
        key = ftok(".",7);
        int shmID = shmget(key,1024*4,IPC_CREAT|0777);
        if (shmID==-1)
        printf("shmget error\n");
        char *shmaddr = shmat(shmID,0,0);
        strcpy(shmaddr,"send from shmwrite.c");
        printf("shmat is ok\n");
        printf("shmaddr :%s\n",shmaddr);
        sleep(3);
        shmdt(shmaddr);
        shmctl(shmID,IPC_RMID,0);
        return 0;
}



shmread.c
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<stdlib.h>
#include<string.h>

int main()
{
        key_t key;
        key = ftok(".",7);
        int shmID = shmget(key,1024*4,0);
        if (shmID==-1)
        printf("shmget error\n");
        char *shmaddr = shmat(shmID,0,0);

        printf("shmat is ok\n");
        printf("send shmaddr :%s\n",shmaddr);

        shmdt(shmaddr);
        shmctl(shmID,IPC_RMID,0);
        return 0;
}

如果写段和读端同时写入数据到共享内存中，就会造成数据的杂乱，这就要通过信号量来控制，使写段写的时候，读端不能写。

Linux信号

参考文章：Linux 信号（signal） - 简书 (jianshu.com)

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

信号概述

信号的名字和编号：

每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。
信号定义在signal.h头文件中，信号名都定义为正整数。
具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用

信号的处理：

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

忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是 SIGKILL和SIGSTOP）。因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的的进程，显然是内核设计者不希望看到的场景

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

系统默认动作，对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。
具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。在此，我就不详细展开了，需要查看的，可以自行查看。也可以参考《UNIX 环境高级编程（第三部）》的 P251——P256中间对于每个信号有详细的说明。

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

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

信号处理函数的注册

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

高级版和入门版的区别：入门版类似于只能发出动作而不能发信息，高级版本能产生动作的同时发送信息。

入门版：函数signal
高级版：函数sigaction

信号捕抓与绑定。

 #include <stdio.h>
#include <signal.h>

//       typedef void (*sighandler_t)(int);    定义了一个函数指针的类型

  //     sighandler_t signal(int signum, sighandler_t handler);    
//sighandler_t handler上述函数指针类型的一个函数。

void handler(int sign)
{

        printf("sign num:%d\n",sign);
        switch(sign)
        {
                case 2: printf("SIGINT never quit\n");
                        break;
                case 9:printf("SIGKILL never quit\n");
                        break;
                case 10:printf("SIGUSR1 never quit\n");
                        break;
        }

}


int main()
{
        signal(SIGINT,handler);
        signal(SIGKILL,handler);
        signal(SIGUSR1,handler);

        while(1);
        return 0;
}

根据函数原型可以看出由两部分组成，一个是真实处理信号的函数，另一个是注册函数了。
对于sighandler_t signal(int signum, sighandler_t handler);函数来说，signum 显然是信号的编号，handler 是中断函数的指针。
同样，typedef void (*sighandler_t)(int);中断函数的原型中，有一个参数是 int 类型，显然也是信号产生的类型，方便使用一个函数来处理多个信号。

信号处理发送函数

信号发送函数也不止一个，同样分为入门版和高级版
1.入门版：kill
2.高级版：sigqueue

信号处理发送函数
1.
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>


//int nt kill(pid_t pid, int sig);


int main(int argc,char **argv)
{
        int signum;
        int pidnum;
        pidnum = atoi(argv[1]);    //atoi把字符转为整型。
        signum = atoi(argv[2]);

        printf("pidnum = %d,signum = %d\n",pidnum,signum);
        kill(pidnum,signum);
        printf("kill is ok\n");
        return 0;
}

2.用system函数调用。

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>


//int nt kill(pid_t pid, int sig);


int main(int argc,char **argv)
{
        int signum;
        int pidnum;
        char cmd[128]={0};
        pidnum = atoi(argv[1]);
        signum = atoi(argv[2]);

        printf("pidnum = %d,signum = %d\n",pidnum,signum);
        sprintf(cmd,"kill -%d %d",signum,pidnum);
        system(cmd);
        printf("kill is ok\n");
        return 0;
}

如何忽略信号？

SIG_IGN 为忽略

信号注册函数——高级版

我们已经成功完成了信号的收发，那么为什么会有高级版出现呢？其实之前的信号存在一个问题就是，虽然发送和接收到了信号，可是总感觉少些什么，既然都已经把信号发送过去了，为何不能再携带一些数据呢？
正是如此，我们需要另外的函数来通过信号传递的过程中，携带一些数据。咱么先来看看发送的函数吧。

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只能任选其一

参数明说：sigaction 是一个系统调用，根据这个函数原型，我们不难看出，在函数原型中，第一个参数signum应该就是注册的信号的编号；第二个参数act如果不为空说明需要对该信号有新的配置；第三个参数oldact如果不为空，那么可以对之前的信号配置进行备份，以方便之后进行恢复。

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

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

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

信号发送函数——高级版

#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 成员，那么将无法获取额外携带的数据。

*P2的结构体signfo_t 这个结构体主要适用于记录接收信号的一些相关信息。

其中的成员很多，si_signo 和 si_code 是必须实现的两个成员。可以通过这个结构体获取到信号的相关信息。
关于发送过来的数据是存在两个地方的，sigval_t si_value这个成员中有保存了发送过来的信息；同时，在si_int或者si_ptr成员中也保存了对应的数据。

框架图：

没有关系的两个进程发送信号（数字）

sigaction.c

#include<stdio.h>
#include <signal.h>

//int sigaction(int signum, const struct sigaction *act,
//   struct sigaction *oldact);

void    handler(int signum, siginfo_t *buf, void *context)
{
        if(context != NULL){
        switch(signum)
        {
                case 2:printf("SIGINT from send,%d getpid = %d\n",buf->si_int,buf->si_pid);
                        break;
                case 10:printf("SIGUSR1 from send,%d getpid = %d\n",buf->si_value.sival_int,buf->si_pid);
                        break;

        }

    }


}

int main()
{
        struct sigaction act;
        printf("getpid = %d\n",getpid());
        act.sa_sigaction = handler;
        act.sa_flags = SA_SIGINFO;
        int intret = sigaction(SIGINT,&act,NULL);
        int usr1ret = sigaction(SIGUSR1,&act,NULL);

        if(intret != 0&& usr1ret != 0){
        printf("sigaction is error");
        perror("why");}

        while(1);
        return 0;
}

sigqueue.c

#include<stdio.h>
#include <signal.h>


int main(int argc,char ** argv)
{
        if(argc !=4)
        printf("input error!\n");
        union sigval vl;  
        int signum = atoi(argv[1]);
        int pid = atoi(argv[2]);
        vl.sival_int = atoi(argv[3]);
        printf("tset:%d,getpid = %d\n",vl.sival_int,getpid());
        int queue = sigqueue(pid,signum,vl);
        if(queue!=-1) 
        printf("send is ok\n");
        return 0;
}

父子进程可以发送字符串，跨进程不能，跨进程只能发送数字。

父子进程sigaction发送字符串

#include<stdio.h>
#include <signal.h>

//int sigaction(int signum, const struct sigaction *act,
//   struct sigaction *oldact);

void    handler(int signum, siginfo_t *buf, void *context)
{
        if(context != NULL){
        switch(signum)

        {
                case 2:printf("SIGINT from send,%s getpid = %d\n",buf->si_ptr,buf->si_pid);
                        break;
                case 10:printf("SIGUSR1 from send,%s getpid = %d\n",buf->si_value.sival_ptr,buf->si_pid);
                        break;

        }

    }


}

int main(int argc,char ** argv)
{
        pid_t ret;
        ret = fork();
        if(ret > 0){
        struct sigaction act;
        printf("getpid = %d\n",getpid());
        act.sa_sigaction = handler;
        act.sa_flags = SA_SIGINFO;
        int intret = sigaction(SIGINT,&act,NULL);

        int usr1ret = sigaction(SIGUSR1,&act,NULL);

        if(intret != 0&& usr1ret != 0){
        printf("sigaction is error");
        perror("why");}

        while(1);
        }

        if(ret == 0){
                if(argc !=3)
        printf("input error!\n");
        union sigval vl;
        int signum = atoi(argv[1]);
        vl.sival_ptr = argv[2];
        printf("tset:%s,getpid = %d\n",vl.sival_ptr,getpid());
        int queue = sigqueue(getppid(),signum,vl);
        if(queue!=-1)
        printf("send is ok\n");
        }

        return 0;
}

信号量的概述

框架图

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

1、特点

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

2、原型

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

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


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

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

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

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

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
//  int semget(key_t key, int num_sems, int sem_flags);

           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;
        set.sem_op = -1;
        set.sem_flg = SEM_UNDO;
        semop(id,&set,1);// 第三个参数是代表有多个struct sembuf set（set可以是数组）
        printf("get the key\n");
}

void vPutbackkey(int id)
{
        struct sembuf set;
        set.sem_num = 0;
        set.sem_op = 1;
        set.sem_flg = SEM_UNDO;
        semop(id,&set,1);
        printf("put back key\n");
}



int main()
{
        key_t key;
        key = ftok(".",2);

        int semID = semget(key,1,IPC_CREAT|0666);
        if(semID != -1)
        printf("semget success!\n");

        union semun initsem;

        initsem.val = 0;

        semctl(semID,0,SETVAL,initsem);    //初始化sem

        int pid = fork();
        if(pid > 0)
        {
                pGetkey(semID);
                printf("this is father\n");
                vPutbackkey(semID);
        }
        else if(pid == 0)
        {

                printf("this is son\n");
                vPutbackkey(semID);
        }
        else{
                printf("fork error\n");
        }

        return 0;
}