Linux-进程间的通信

1、IPC：

Inter Process Communication（进程间通信）：

由于每个进程在操作系统中有独立的地址空间，它们不能像线程那样直接访问彼此的内存，所以必须通过某种方式进行通信。

常见的 IPC 方式包括： 2、无名管道：

管道的概念：

本质：

1、内核缓冲区；

2、伪文件-不占用磁盘空间；

特点：

1、读端，写端对应两个文件描述符；

2、数据写端流入，读端流出；

3、操作管理的进程被销毁之后，管道自动被释放；

4、管道默认式阻塞的；

创建匿名管道：

示例：

int pipe(int fd[2])

fd‐传出参数：
fd[0]‐读端
fd[1]‐写端

返回值：
0：成功
‐1：创建失败

实验：父子进程使用管道进行通信，实现 ps aux | grep “bash”：

使用父子进程管道通信时读端和写端不能同时打开，父进程打开写端关闭读端；

#include<stdio.h>
#include<stdlib.h>
#include <unistd.h>

int main()
{

        int ret;
        int fd[2];
        pid_t pid;
        ret = pipe(fd);
        pid  = fork();
        if(ret == -1)
        {
                printf("create pipe failed!");
                exit(1);
        }
        //ps aux
        if(pid>0)
        {
                close(fd[0]);//guanbi du duan da kai xie duan
                dup2(fd[1],STDOUT_FILENO);
                execlp("ps","ps","aux",NULL);
                exit(1);

        }
        //grep bush
        if(pid==0)
        {

                close(fd[1]);//guanbi xieduan da kai duduan
                dup2(fd[0],STDIN_FILENO);
                execlp("grep","grep","bush",NULL);

        }

        printf("pipe[0] is %d\n",fd[0]);
        printf("pipe[1] is %d\n",fd[1]);

        return 0;
}
~

结果：

3、有名管道：

示例：

int mkfifo(const char \*filename, mode_t mode)

功能： 创建管道文件；

参数： 管道文件名，权限，创建的文件权限和umask有关；

返回值： 创建成功返回0，创建失败返回-1；

特点：

有名管道；

伪文件，不占用磁盘空间；

半双工通信方式；

使用场景：

用于实现无血缘关系的进程间通信，使用mkfifo函数只会在用户区创建一个节点，不会在内核区创建管道，需要使用IO函数OPEN函数打开管道；

ret = mkfifo("/home/study/ipc/mkfifo",0755);
 
fd = open("./mkfifo",O_RDONLY);

实验：创建一个管道，让进程A写入进程B读出：

读进程：

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>

int main()
{
        int ret;
        int fd;
        int nred;
        char readbuf[50]={0};
        //ret = mkfifo("/home/study/ipc/mufifo",0755);

        if(ret == -1)
        {
                printf("filed!");

        }
        printf("create success\n");

        fd = open("./mufifo",O_RDONLY);
        if(fd == -1)
        {
                printf("open filed\n");
        }
        printf("open success\n");

        nred = read(fd,readbuf,50);
        printf("read %d byte from fifo %s\n",nred,readbuf);
        printf("second read %d byte from fifo %s\n",nred,readbuf);
        close(fd);
        return 0;
}
~

写进程：

#include<stdio.h>
#include<string.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
int main()
{
        char *str = "hello world";
        int fd;
        int ret;
        ret = mkfifo("/home/study/ipc/mufifo",0755);


        fd = open("./mufifo",O_WRONLY);

        if(fd < 0)
        {
                return -1;
        }
        printf("open fifo success\n");

        write(fd,str,strlen(str));

        close(fd);
        return 0;

}

结果：

注意：管道中的信息只能读取一次，读取完之后数据就被移除，但是管道还存在；

4、消息队列：

概念：

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

特点：

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

消息队列独立于发送和接收进程，进程终止时，消息队列及其内容仍存在；

消息队列可以实现消息的随即查询，消息不一定要先进先出的次序读取，也可以按照消息类型进行读取；

两个进程间的通信：通过识别链表的ID来进行读写实现收发；

4、共享内存：

概念：

共享内存（Shared Memory）就是允许多个进程访问同一个内存空间，是在多个进程之间共享和传递数据最高效的方式。操作系统将不同进程之间共享内存安排为同一段物理内存，进程可以将共享内存连接到它们自己的地址空间中，如果某个进程修改了共享内存中的数据，其它的进程读到的数据也将会改变；

共享内存会从内核区映射一个地址空间到用户区，需要访问用户区的地址空间才能实现读写功能；

相关函数：

1.int shmget(key_t key, size_t size, int shmflg);
//用来获取或创建共享内存
参数：
key：IPC_PRIVATE 或 ftok的返回值
size：共享内存区大小
shmflg：同open函数的权限位，也可以用8进制表示法
返回值：
成功：共享内存段标识符‐‐‐ID‐‐‐文件描述符
出错：‐1

2.void *shmat(int shm_id, const void *shm_addr, int shmflg);
//把共享内存连接映射到当前进程的地址空间
参数：
shm_id:ID号
shm_addr:映射到的地址，NULL为系统自动完成的映射
shmflg：
SHM_RDONLY共享内存只读
默认是0，表示共享内存可读写
返回值：
成功：映射后的地址
失败：NULL

3.int shmdt(const void *shmaddr);
//将进程里的地址映射删除
参数：
shmid：要操作的共享内存标识符
返回值：
成功：0
出错：‐1

4.int shmctl(int shm_id, int command, struct shmid_ds *buf);
//删除共享内存对象
参数：
shmid：要操作的共享内存标识符
cmd ：
IPC_STAT (获取对象属性)‐‐‐ 实现了命令ipcs ‐m
IPC_SET (设置对象属性)
IPC_RMID (删除对象) ‐‐‐实现了命令ipcrm ‐m
buf ：指定IPC_STAT/IPC_SET时用以保存/设置属性
返回值：
成功：0
出错：‐1

实验：生成共享内存，并通过标准输入写入共享内存，并读出来打印屏幕上；

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>      // fork()
#include <sys/ipc.h>     // 共享内存所需
#include <sys/shm.h>     // shmget, shmat

int main()
{
        int shmid;
        int key;
        char *p;
        key = ftok("alarm.c",1);
        if(key<0)
        {
                printf("ftok failure\n");
                return -1;
        }
        printf("ftok success key:%x\n",key);
        shmid = shmget(key,128,IPC_CREAT|0777);
        if(shmid<0)
        {
                printf("create failure\n");
                return -2;
        }
        printf("create succ");
        system("ipcs -m");

        p = (char *)shmat(shmid,NULL,0);
        if(p = NULL)
        {
                printf("shmat funtion failure\n");
                return -3;
        }
        //write to
        fgets(p,128,stdin);
        //read
        printf("share data is %s",p);
        return 0;
}

结果：

5、信号：

信号通信的框架：

信号通信的框架：
    信号的发送（发送信号的进程）：kill、raise、alarm
    信号的接收（接收信号的进程）：pause（）、sleep、while（1）
    信号的处理（接收信号的进程）：signal

5.1、信号的发送（发送信号的进程）：

1、kill：

#include<signal.h>
#include<sys/types.h>
函数原型：int kill(pid_t pid, int sig);
参数：
函数传入值：pid
正数：要接收信号的进程的进程号
0：信号被发送到所有和pid进程在同一个进程组的进程
‐1：信号发给所有的进程表中的进程(除了进程号最大的进程外)
sig：信号
函数返回值：成功 0 出错 ‐1

2、raise：发送信号给自己 == kill(getpid() , sig)

所需头文件:
#include<signal.h>
#include<sys/types.h>
函数原型：
int raise(int sig);
参数：
函数传入值：sig：信号
函数返回值：
成功 0 出错 ‐1

实验：raise==kill（getpid（），sig）：

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


int main()
{

        printf("before sig\n");
        raise(9);
        printf("after sig\n");
        return 0 ;
}
~

结果：打印完“before sig”后进程执行kill动作，结束进程，不会打印“after sig”；

5.2、alarm：发送闹钟信号的函数：

5.2.1、alarm与raise函数的比较：

相同点：让内核发送信号给进程

不同点：alarm只会发送SIGALARM信号；

alarm会让内核定时一段时间在发送信号，raise会立即发送信号；

所需头文件#include <unistd.h>
函数原型 unsigned int alarm(unsigned int seconds)
参数：
seconds：指定秒数
返回值：
成功：如果调用此alarm()前，进程中已经设置了闹钟时间，则 返回上一个闹钟时间的剩余时间，否则返回0。
出错：‐1

实验：定时7秒向进程发送信号：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{

        int i = 0;
        printf("before alarm\n");
        alarm(7);
        printf("after alarm\n");
        while(i<20)
        {
                i++;
                sleep(1);
                printf("process %d\n",i);

        }
        return 0;

}

结果：

在第7秒时想进程发送信号，但是由于没有设置信号处理函数对这个信号进行处理，所以这个信号会让进程终止；

信号的含义及默认操作：

信号名	含义	默认操作
SIGHUP	该信号在用户终端连接 ( 正常或非正常 ) 结束时发出，通常是在终端的控制进程结束时，通知同一会话内的各个作业与控制终端不再关联。	终止
SIGINT	该信号在用户键入 INTR 字符 ( 通常是 Ctrl-C) 时发出，终端驱动程序发送此信号并送到前台进程中的每一个进程。	终止
SIGQUIT	该信号和 SIGINT 类似，但由 QUIT 字符 ( 通常是 Ctrl-) 来控制。	终止
SIGILL	该信号在一个进程企图执行一条非法指令时 ( 可执行文件本身出现错误，或者试图执行数据段、堆栈溢出时) 发出。	终止
SIGFPE	该信号在发生致命的算术运算错误时发出。这里不仅包括浮点运算错误，还包括溢出及除数为0 等其它所有的算术的错误。	终止
SIGKILL	该信号用来立即结束程序的运行，并且不能被阻塞、处理和忽略	终止
SIGALRM	该信号当一个定时器到时的时候发出。	终止
SIGSTOP	该信号用于暂停一个进程，且不能被阻塞、处理或忽略	暂停进程
SIGTSTP	该信号用于暂停交互进程，用户可键入 SUSP 字符 ( 通常是 Ctrl-Z) 发出这个信号	暂停进程
SIGCHLD	子进程改变状态时，父进程会收到这个信号	忽略
SIGABORT	该信号用于结束进程	终止

5.3、信号的处理：

收到信号的进程，应该怎样处理？

处理的方式：

1、进程的默认处理（内核为用户进程设置的默认处理方式）

A：忽略、B：终止进程、C：暂停

2、自己的处理方式：自己处理信号的方法告诉内核，这样你的进程收到了这个信号就会采用你自己的的处理方式

所需头文件 #include <signal.h>
函数原型 void (*signal(int signum, void (*handler)(int)))(int);
函数传入值
signum：指定信号
handler
SIG_IGN：忽略该信号。
SIG_DFL：采用系统默认方式处理信号
自定义的信号处理函数指针
函数返回值
成功：设置之前的信号处理方式
出错：‐1
signal 函数有二个参数，第一个参数是一个整形变量（信号值），第二个参数是一个函数指针，是我们自己写的处理函
数；这个函数的返回值是一个函数指针。

6、信号灯

信号灯集合（可以包含多个信号灯）IPC对象是一个信号的集合（多个信号量）

1、semget

函数原型： int semget(key_t key, int nsems, int semflg);
//创建一个新的信号量或获取一个已经存在的信号量的键值。
所需头文件：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
函数参数：
key：和信号灯集关联的key值
nsems: 信号灯集中包含的信号灯数目
semflg：信号灯集的访问权限
函数返回值：
成功：信号灯集ID
出错：‐1

2、semctl：

函数原型：int semctl ( int semid, int semnum, int cmd，…union semun arg(不是地址));
//控制信号量，删除信号量或初始化信号量
所需头文件：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
函数参数：
semid：信号灯集ID
semnum: 要修改的信号灯编号
cmd :
GETVAL：获取信号灯的值
SETVAL：设置信号灯的值
IPC_RMID：从系统中删除信号灯集合
函数返回值：
成功：0
出错：‐1

3、P V 操作：

int semop(int semid ,struct sembuf *sops ,size_t nsops);
//用户改变信号量的值。也就是使用资源还是释放资源使用权
包含头文件：
include<sys/sem.h>
参数：
semid : 信号量的标识码。也就是semget（）的返回值
sops是一个指向结构体数组的指针。
struct sembuf{
unsigned short sem_num；//信号灯编号；
short sem_op;//对该信号量的操作。‐1 ，P操作，1 ，V操作
short sem_flg;0阻塞，1非阻塞
};
sem_op : 操作信号灯的个数
//如果其值为正数，该值会加到现有的信号内含值中。通常用于释放所控资源的使用权；如果sem_op的值为负
数，而其绝对值又大于信号的现值，操作将会阻塞，直到信号值大于或等于sem_op的绝对值。通常用于获取资源的使用
权；如果sem_op的值为0，则操作将暂时阻塞，直到信号的值变为0。

实验：通过信号灯操作和共享内存来共同实现父子进程通信：

实现思路：

1、声明 P V 操作并进行初始化：p v操作需要配置函数，在使用P V都可以这样进行配置

void Poperation(int index,int semid)
{
        struct sembuf sop;
        sop.sem_num = index;
        sop.sem_op = -1;
        sop.sem_flag = 0;

        semop(semid,&sop,1);


}

void Voperation(int index,int semid)
{
        struct sembuf sop;
        sop.sem_num = index;
        sop.sem_op = 1;
        sop.sem_flg = 0;

        semop(semid,&sop,1);


}

2、使用union semun初始化信号量：常与semctl()函数一起使用

union semun
{

        int val;
}

3、生成共享内存：

 int shmid; 
 char *shmaddr;       
 shmid = shmget(key,128,IPC_CREAT|0755);

4、宏定义读写两个信号量：

#define SEM_WRITE 1
#define SEM_READ 0

5、使用semctl函数来控制读写两个信号量：

 //init semaphore
        union semum myun;
        //init semaphore read
        myun.val=0;
        semctl(semid,SEM_READ,SETVAL,myun);
        //init semaphore write
        myun.val = 1;
        semctl(semid,SEM_WRITE,SETVAL,myun);

6、生成父子进程，并分别实现父子进程的动作：

父进程实现从键盘输入，并执行写操作，读操作暂停：

子进程执行读操作，写操作暂停；

       pid_t pid;
       pid = fork();
        if(pid == 0)//child process
        {
                while(1)
                {
                        shmaddr = (char *)shmat(shmid,NULL,0);

                        Poperation(SEM_READ,semid);
                        printf("get share memory is %s\n",shmaddr);
                        Voperation(SEM_WRITE,semid);
                }
        }
        else if(pid>0)//father process
        {
                while(1)
                {
                        shmaddr =( char *)shmat(shmid,NULL,0);

                        Poperation(SEM_WRITE,semid);
                        printf("please input to share memory\n");
                        fgets(shmaddr,32,stdin);
                        Voperation(SEM_READ,semid);
                }

        }

完整代码：

#include<stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>

#define SEM_WRITE 1
#define SEM_READ 0


//ding yi xin hao lian he ti 
// 必须手动定义 semun union，因为它不在标准头文件中定义
union semun {
    int val;                // 用于 SETVAL
    struct semid_ds *buf;   // 用于 IPC_STAT 和 IPC_SET
    unsigned short *array;  // 用于 GETALL 和 SETALL
    struct seminfo *__buf;  // 用于 IPC_INFO（可选，可以忽略）
};


void Poperation(int index,int semid)
{
        struct sembuf sop;
        sop.sem_num = index;
        sop.sem_op = -1;
        sop.sem_flg = 0;

        semop(semid,&sop,1);


}

void Voperation(int index,int semid)
{
        struct sembuf sop;
        sop.sem_num = index;
        sop.sem_op = 1;
        sop.sem_flg = 0;
        semop(semid,&sop,1);


}

void Voperation(int index,int semid)
{
        struct sembuf sop;
        sop.sem_num = index;
        sop.sem_op = 1;
        sop.sem_flg = 0;

        semop(semid,&sop,1);


}

int main()
{

        key_t key;
        key = ftok(".",123);
        if(key == -1)
        {
                perror("ftok");
                return -1;
        }
        int semid;
        int shmid;
        char *shmaddr;
        semid = semget(key,2,IPC_CREAT|0755);
        if(semid<0)
        {
                perror("semget");
                return -1;
        }
        shmid = shmget(key,128,IPC_CREAT|0755);
        if(shmid<0)
        {

                perror("shmget");
                return -2;
 }
        //init semaphore
        union semun myun;
        //init semaphore read
        myun.val=0;
        semctl(semid,SEM_READ,SETVAL,myun);
        //init semaphore write
        myun.val = 1;
        semctl(semid,SEM_WRITE,SETVAL,myun);

        pid_t pid;
        pid = fork();
        if(pid == 0)//child process
        {
                while(1)
                {
                        shmaddr = (char *)shmat(shmid,NULL,0);

                        Poperation(SEM_READ,semid);
                        printf("get share memory is %s\n",shmaddr);
                        Voperation(SEM_WRITE,semid);
                }
        }
        else if(pid>0)//father process
        {
                while(1)
                {
                        shmaddr =( char *)shmat(shmid,NULL,0);

                        Poperation(SEM_WRITE,semid);
                        printf("please input to share memory\n");
                        fgets(shmaddr,32,stdin);
                        Voperation(SEM_READ,semid);
                }

        }
        return 0;


}

结果：父子进程就会交替执行读写操作，并不会同时占用共享内存：