一、进程间通信（IPC）
1.1 进程间通信的引入
1> 对于多个线程之间通信，我们可以使用临界资源来完成，通过一个线程任务对临界资源进行修改，另一个线程也可以使用已经修改过的临界资源，但是要注意使用同步互斥机制完成对临界资源的保护
2> 多个进程之间能否使用全局变量来进行进程间通信？
答：不能，多个进程之间的用户空间是相互独立的，每个进程的全局变量是各个进程独立拥有的，更改一个进程的全局变量，另一个进程不会受到影响，故而不能使用全局变量来完成通信
3> 有同学说：使用文件来完成进程间通信？
答：可行，但是要求写进程先完成向文件中写入数据，然后读进程才能读取数据，必须要加入进程的同步操作
4> 多个进程之间内核空间是共享的，我们可以通过将数据放入到内核空间，来完成两个进程之间信息的交流
5> 进程间通信方式：
1、内核提供的原始通信方式
无名管道
有名管道
信号
2、system V提供三种
消息队列
共享内存
信号量集
1.2 无名管道
1> 顾名思义就是没有名字的管道文件，所以只能适用于亲缘进程间的通信
2> 原理：通过内核，在内存中创建出一个管道文件，存放在内存空间，并不在文件系统中真实存在。当打开该文件时，会返回该文件的两个文件描述符，分别对应读端和写端。可以通过读端从管道中读取数据，从写端向管道中写入数据。当该文件的读写两端全部被关闭后，该管道文件会在内存中消失
3> 注意：由于打开管道时返回的是文件描述符，所以，对该文件的操作，只能使用文件IO
对于存入管道中的数据的读取是一次性的，当数据读取结束后，数据就不存在于管道文件中了
4> 无名管道的API接口函数
#include <unistd.h>
int pipe(int pipefd[2]);
功能：在通过内核在内存中创建一个无名管道，并通过参数将该管道文件的两个文件描述符返回
参数：接收文件描述符的数组，pipefd[0]表示管道文件的读端，pipefd[1]表示管道的写端
返回值：成功返回0，失败返回-1并置位错误码
#include<myhead.h>
int main(int argc, const char *argv[])
{
//创建用于通信的管道文件，并返回该文件对应的文件描述符
int pipefd[2] ;
if(pipe(pipefd)==-1)
{
perror("pipe error");
return -1;
}
//创建父子进程
pid_t pid = fork();
if(pid < 0)
{
perror("fork error");
return -1;
}else if(pid == 0)
{
//子进程
close(pipefd[1]); //关闭写端
//接受父进程发来的消息
char rbuf[128] = "";
while(1)
{
bzero(rbuf, sizeof(rbuf));
//从管道中读取数据
read(pipefd[0], rbuf, sizeof(rbuf));
if(strcmp(rbuf, "quit")==0)
{
break;
}
//输出数据
printf("收到父进程的来信：%s\n", rbuf);
}
//关闭读段
close(pipefd[0]);
//退出进程
exit(EXIT_SUCCESS);
}
//父进程
char sbuf[128] = "";
//关闭读端
close(pipefd[0]);
while(1)
{
usleep(10);
printf("父进程中输入>>>");
fgets(sbuf, sizeof(sbuf), stdin); //从终端获取字符串
sbuf[strlen(sbuf)-1] = 0;
//发送给子进程,将数据通过写端写入管道 pipefd[1]
write(pipefd[1], sbuf, strlen(sbuf));
//判断终端获取的数据
if(strcmp(sbuf, "quit") == 0)
{
break;
}
//关闭写端
close(pipefd[1]);
}
//回收子进程资源
wait(NULL);
return 0;
}
5> 总结管道通信的特点
1、管道通信是半双工的通信方式
单工：任意时刻只能A向B发送消息，B不能向A发送消息
半双工：同一时刻，只能A向B发送消息或者B向A发消息
全双工：任意时刻，AB可以互相发送消息
2、无名管道只适用于亲缘进程间通信
3、无名管道也能完成自己跟自己的通信
4、无名管道文件的大小：64KB
6> 管道的读写特点（笔试面试）
1、当管道读端存在时，写管道有多少写多少，直到写满64K为止
2、当管道读端不存在时，写管道写入数据时，会出现管道破裂，此时内核空间会向用户空间发送一个SIGPIPE信号
3、当写端存在时，读管道有多少读多少，没有数据会在read处阻塞
4、当写端不存在时，读管道有多少读多少，没有数据也不会在read处阻塞
#include<myhead.h>
int main(int argc, const char *argv[])
{
//创建一个五名管道
int fds[2];
if(pipe(fds) == -1)
{
perror("pipe error");
return -1;
}
//向管道中写入数据
char buf = 'A';
int count = 0; //记录写入的大小
while(1)
{
write(fds[1], &buf, 1);
count ++;
printf("count = %d\n", count);
//关闭读端
close(fds[0]);
}
while(1);
return 0;
}
#include<myhead.h>
int main(int argc, const char *argv[])
{
//创建用于通信的管道文件，并返回该文件对应的文件描述符
int pipefd[2] ;
if(pipe(pipefd)==-1)
{
perror("pipe error");
return -1;
}
//创建父子进程
pid_t pid = fork();
if(pid < 0)
{
perror("fork error");
return -1;
}else if(pid == 0)
{
//子进程
close(pipefd[1]); //关闭写端
//接受父进程发来的消息
char rbuf[128] = "";
while(1)
{
bzero(rbuf, sizeof(rbuf));
//从管道中读取数据
read(pipefd[0], rbuf, sizeof(rbuf));
if(strcmp(rbuf, "quit")==0)
{
break;
}
//输出数据
printf("收到父进程的来信：%s\n", rbuf);
}
//关闭读段
close(pipefd[0]);
//退出进程
exit(EXIT_SUCCESS);
}
//父进程
char sbuf[128] = "";
//关闭读端
close(pipefd[0]);
while(1)
{
usleep(10);
printf("父进程中输入>>>");
fgets(sbuf, sizeof(sbuf), stdin); //从终端获取字符串
sbuf[strlen(sbuf)-1] = 0;
//发送给子进程,将数据通过写端写入管道 pipefd[1]
write(pipefd[1], sbuf, strlen(sbuf));
//判断终端获取的数据
if(strcmp(sbuf, "quit") == 0)
{
break;
}
//关闭写端
close(pipefd[1]);
}
//关闭写端
close(pipefd[1]);
//回收子进程资源
wait(NULL);
return 0;
}
1.3 有名管道
1> 顾名思义就是有名字的管道文件，会在文件系统中创建一个有名字的管道文件
2> 可以用于亲缘进程间的通信，也可以用于非亲缘进程间的通信
3> 有名管道的API函数
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
功能：在文件系统中创建一个有名管道，但是并没有打开该文件
参数1：有名管道的名称
参数2：管道文件的权限
返回值：成功返回0，失败返回-1并置位错误码
create.c
#include<myhead.h>
int main(int argc, const char *argv[])
{
//创建一个有名管道文件
if(mkfifo("./linux", 0664)==-1)
{
perror("mkfifo error");
return -1;
}
getchar();
system("rm linux");
return 0;
}
snd.c
#include<myhead.h>
int main(int argc, const char *argv[])
{
//以写的形式打开管道文件
int wfd = open("./linux", O_WRONLY);
if(wfd == -1)
{
perror("open error");
return -1;
}
printf("管道文件已经打开\n");
//发送数据
char wbuf[128] = "";
while(1)
{
printf("请输入>>>>");
fgets(wbuf, sizeof(wbuf), stdin);
wbuf[strlen(wbuf)-1] = 0;
//将数据发送给到管道中
write(wfd, wbuf, strlen(wbuf));
//判断数据
if(strcmp(wbuf, "quit") == 0)
{
break;
}
}
//关闭文件描述符
close(wfd);
return 0;
}
recv.c
#include<myhead.h>
int main(int argc, const char *argv[])
{
//以读的形式打开文件
int rfd = open("./linux", O_RDONLY);
if(rfd == -1)
{
perror("open error");
return -1;
}
printf("管道文件读端打开\n");
//定义接受容器
char rbuf[128] = "";
while(1)
{
bzero(rbuf, sizeof(rbuf));
//读取数据
read(rfd, rbuf, sizeof(rbuf));
if(strcmp(rbuf, "quit") == 0)
{
break;
}
printf("收到消息为：%s\n", rbuf);
}
//关闭文件描述符
close(rfd);
return 0;
}
1.4 信号通信
1> 信号通信原理图：两个异步通信的进程之间，通过发送相关信号，完成任务间的通信
2> 信号是linux中软件模拟硬件的“中断”的一种方式。信号是软件部分的名词，中断是硬件部分的名词
3> 能够发送的信号可以通过指令：kill -l进行查看
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
4> 对于信号的处理方式有三种：默认、捕获、忽略
有两个信号既不能被捕获，也不能被忽略：SIGKILL、SIGSTOP
5> 上面的信号触发条件以及默认处理方式可以通过指令 man 7 signal进行查看
Signal Value Action Comment
──────────────────────────────────────────────────────────────────────
SIGHUP 1 Term Hangup detected on controlling terminal
or death of controlling process
SIGINT 2 Term Interrupt from keyboard
SIGQUIT 3 Core Quit from keyboard
SIGILL 4 Core Illegal Instruction
SIGABRT 6 Core Abort signal from abort(3)
SIGFPE 8 Core Floating-point exception
SIGKILL 9 Term Kill signal
SIGSEGV 11 Core Invalid memory reference
SIGPIPE 13 Term Broken pipe: write to pipe with no
readers; see pipe(7)
SIGALRM 14 Term Timer signal from alarm(2)
SIGTERM 15 Term Termination signal
SIGUSR1 30,10,16 Term User-defined signal 1
SIGUSR2 31,12,17 Term User-defined signal 2
SIGCHLD 20,17,18 Ign Child stopped or terminated
SIGCONT 19,18,25 Cont Continue if stopped
SIGSTOP 17,19,23 Stop Stop process
SIGTSTP 18,20,24 Stop Stop typed at terminal
SIGTTIN 21,21,26 Stop Terminal input for background process
SIGTTOU 22,22,27 Stop Terminal output for background process
6> 信号的发送者可以是内核、其他进程、用户自己
7> 将信号与信号处理方式连接函数
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
功能：将信号与信号处理函数绑定到一起
参数1：要绑定的信号
参数2：信号处理函数
SIG_IGN：表示忽略信号
SIG_DFL：表示默认处理
填自定义函数的入口地址
返回值：成功返回处理方式的起始地址，失败返回 SIG_ERR
#include<myhead.h>
//自定义处理信号的函数
void handler(int signo)
{
//判断传过来的信号是哪个
if(signo == SIGINT)
{
printf("当前进程收到了ctrl + c，但是就是关不掉\n");
}
//判断是否为SIGKILL到位
if(signo == SIGKILL)
{
printf("捕获了SIGKILL\n");
}
}
/**************************主程序*******************/
int main(int argc, const char *argv[])
{
//将2号信号与对应的信号处理函数进行绑定
/*尝试忽略2号信号
if(signal(2, SIG_IGN) == SIG_ERR)
{
perror("signal error");
return -1;
}
*/
//尝试捕获2号信号
if(signal(2, handler) == SIG_ERR)
{
perror("signal error");
return -1;
}
/*尝试忽略SIGKILL信号：报错，参数不合法
if(signal(SIGKILL, handler) == SIG_ERR)
{
perror("signal error");
return -1;
}*/
/*尝试捕获SIGKILL信号：报错，参数不合法
if(signal(SIGKILL, handler) == SIG_ERR)
{
perror("signal error");
return -1;
}
*/
/*尝试默认处理:报错，参数不合法
if(signal(SIGKILL, SIG_DFL) == SIG_ERR)
{
perror("signal error");
return -1;
}*/
while(1)
{
printf("啦啦啦啦，我是卖报的小行家\n");
sleep(1);
}
return 0;
}
1.5 特殊的信号处理
1> SIGCHLD信号：以非阻塞的形式回收僵尸进程
#include<myhead.h>
//自定义信号处理函数
void handler(int signo)
{
if(signo == SIGCHLD)
{
while(1)
{
//判断是否将僵尸进程全部回收了
if(waitpid(-1, NULL, WNOHANG) == 0)
{
break;
}
}
}
}
/******************主程序**********************/
int main(int argc, const char *argv[])
{
//将SIGCHLD信号与信号处理函数绑定到一起
if(signal(SIGCHLD, handler) == SIG_ERR)
{
perror("signal error");
return -1;
}
for(int i=0; i<10; i++)
{
if(fork() == 0)
{
exit(EXIT_SUCCESS);
}
}
while(1);
/*
for(;;)
{
printf("我是小妖怪，逍遥游自在\n");
sleep(1);
}*/
return 0;
}
2> SIGALRM：定时器信号
程序允许启动一个定时器，当所定的时间到位后，会发送一个SIGALRM信号，我们可以将该信号绑定到对应的信号处理函数中，从而导致，给定时间后，处理自定义函数。该信号需要使用一个函数来发送超时信号：alarm闹钟函数
#include <unistd.h>
unsigned alarm(unsigned seconds);
功能：给进程设置一个定时器，以秒为单位，当定时器到位后，后向该进程发送一个SIGALRM的信号
参数：秒数，如果参数设置成0，表示删除定时器
返回值：>0:表示返回的上一个定时器剩余的秒数，并且重置上一个定时器
0：表示之前没有设置定时器
#include<myhead.h>
//定义信号处理函数
void handler(int signo)
{
if(signo == SIGALRM)
{
printf("阎王叫你三更死，怎可留人到五更\n");
sleep(2);
exit(EXIT_SUCCESS);
}
}
/********************主程序******************/
int main(int argc, const char *argv[])
{
//将SIGALRM信号与信号处理函数绑定
if(signal(SIGALRM, handler) == SIG_ERR)
{
perror("signal error");
return -1;
}
printf("%d\n", alarm(10)); //0
sleep(5);
printf("%d\n", alarm(10)); //5
int count = 0;
while(1)
{
printf("能活一秒是一秒\n");
sleep(1);
/*
count++;
if(count == 3)
{
alarm(0); //删除定时器
}
*/
}
return 0;
}
使用SIGALRM模拟斗地主出牌
#include<myhead.h>
//定义信号处理函数
void handler(int signo)
{
if(signo == SIGALRM)
{
printf("系统已经自动帮您出了一张牌\n");
alarm(5);
}
}
/*******************主程序**********************/
int main(int argc, const char *argv[])
{
//将信号与信号处理函数绑定
if(signal(SIGALRM, handler) == SIG_ERR)
{
perror("signal error");
return -1;
}
char ch; //要出的牌
while(1)
{
//启动一个定时器
alarm(5);
printf("请出牌>>");
scanf("%c", &ch);
getchar();
printf("您出的牌为：%c\n", ch);
}
return 0;
}
1> 使用有名管道实现，一个进程用于给另一个进程发消息，另一个进程收到消息后，展示到终端上，并且将消息保存到文件上一份
xs.c
#include<myhead.h>
int main(int argc, const char *argv[])
{
//创建一个有名管道文件
if(mkfifo("./linux", 0664)==-1)
{
perror("mkfifo error");
return -1;
}
getchar();
//删除管道文件
system("rm linux");
return 0;
}
cb.c
#include<myhead.h>
int main(int argc, const char *argv[])
{
//以写的形式打开管道文件
int wfd = open("./linux", O_WRONLY);
if(wfd == -1)
{
perror("open error");
return -1;
}
printf("管道文件已经打开\n");
//发送数据
char wbuf[128] = "";
while(1)
{
printf("请输入>>>>");
fgets(wbuf, sizeof(wbuf), stdin);
wbuf[strlen(wbuf)-1] = '\0';
//将数据发送给到管道中
write(wfd, wbuf, strlen(wbuf));
//判断数据
if(strcmp(wbuf, "quit") == 0)
{
break;
}
}
//关闭文件描述符
close(wfd);
return 0;
}
cd.c
#include<myhead.h>
int main(int argc, const char *argv[])
{
//以读的形式打开文件
int rfd = open("./linux", O_RDONLY);
if(rfd == -1)
{
perror("open error");
return -1;
}
printf("管道文件读端打开\n");
int tid = open("./1.txt", O_RDWR);
if(rfd == -1)
{
perror("open error");
return -1;
}
//定义接受容器
char rbuf[128] = "";
while(1)
{
bzero(rbuf, sizeof(rbuf));
//读取数据
read(rfd, rbuf, sizeof(rbuf));
if(strcmp(rbuf, "quit") == 0)
{
break;
}
printf("收到消息为：%s\n", rbuf);
write(tid,rbuf,sizeof(rbuf));
}
//关闭文件描述符
close(rfd);
close(tid);
return 0;
}
2> 使用有名管道实现两个进程间相互通信
day1.c
#include <myhead.h>
int main(int argc, const char *argv[])
{
//创建一个有名管道文件
if (mkfifo("./linux", 0664) == -1)
{
perror("mkfifo error");
return -1;
}
//创建一个有名管道文件
if (mkfifo("./text", 0664) == -1)
{
perror("mkfifo error");
return -1;
}
getchar();
//删除管道文件
system("rm linux");
system("rm text");
return 0;
}
dday1.c
#include <myhead.h>
int main(int argc, const char *argv[])
{
//以写的形式打开管道文件
int wfd = open("./linux", O_WRONLY);
if (wfd == -1)
{
perror("open error");
return -1;
}
printf("管道文件已经打开\n");
int rid = open("./text", O_RDONLY);
if (rid == -1)
{
perror("open error");
return -1;
}
printf("管道文件已经打开\n");
int rp = -1;
if ((rp = fork()) == -1)
{
perror("fork error\n");
}
if (rp > 0)
{
//发送数据
char wbuf[128] = "";
while (1)
{
printf("请输入>>>>\n");
fgets(wbuf, sizeof(wbuf), stdin);
wbuf[strlen(wbuf) - 1] = 0;
//将数据发送给到管道中
write(wfd, wbuf, strlen(wbuf));
//判断数据
if (strcmp(wbuf, "quit") == 0)
{
break;
}
//关闭文件描述符
}
close(wfd);
close(rid);
}
else
{
char sv[128] = "";
while (1)
{
bzero(sv, sizeof(sv));
read(rid, sv, sizeof(sv));
if (strcmp(sv, "quit") == 0)
{
break;
}
printf("接收到的数据为%s\n", sv);
}
close(rid);
close(wfd);
exit(0);
}
wait(NULL);
return 0;
}
day2.c
#include <myhead.h>
int main(int argc, const char *argv[])
{
//以写的形式打开管道文件
int wfd = open("./linux", O_RDONLY);
if (wfd == -1)
{
perror("open error");
return -1;
}
printf("管道文件已经打开\n");
int rid = open("./text", O_WRONLY);
if (rid == -1)
{
perror("open error");
return -1;
}
printf("管道文件已经打开\n");
int rp = -1;
if ((rp = fork()) == -1)
{
perror("fork error\n");
}
if (rp > 0)
{
char sv[128] = "";
while (1)
{
bzero(sv, sizeof(sv));
read(wfd, sv, sizeof(sv));
if (strcmp(sv, "quit") == 0)
{
break;
}
printf("接受到的数据为%s\n", sv);
}
close(rid);
close(wfd);
}
else
{
//发送数据
char wbuf[128] = "";
while (1)
{
printf("请输入>>>>\n");
fgets(wbuf, sizeof(wbuf), stdin);
wbuf[strlen(wbuf) - 1] = 0;
//将数据发送给到管道中
write(rid, wbuf, strlen(wbuf));
//判断数据
if (strcmp(wbuf, "quit") == 0)
{
break;
}
//关闭文件描述符
}
close(wfd);
close(rid);
exit(0);
}
wait(NULL);
return 0;
}
