Linux下并发程序设计（3）——Unix间通信方式（转载）

  线程共享同一进程的地址空间，这个地址空间的代码和全局变量每个线程都可以访问，这样就使得线程的通信很容易。但是在进程中不同的进程有不同的地址空间，那么两个进程之间如何进行通信就成了一个难题，实际中Linux有很多机制来实现两个进程间的通信。
   我们都知道Linux是从Unix发展来的，早期的Unix进程间通过无名管道（pipe）、有名管道（fifo）、信号（signal）的方式进行通信。在System V中进程间通信又有共享内存（share memory）、消息队列(message queue)、信号灯级（semaphore set)的方式。在BSD Unix中进程间通信是通过套接字（socket）。以上的这些进程间通信的方式Linux都继承了下来。

往期推荐:
Linux并发程序设计（1）——进程
Linux并发程序设计（2）——线程

文章目录
进程间通信概念
进程间通信方式
无名管道（pipe）
有名管道（fifo）
信号机制
进程间通信概念
每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）
Alt

进程间通信方式
无名管道（pipe）
无名管道特点:

只能用于具有亲缘关系（父子进程、兄弟进程）的进程之间的通信
管道是单工通信模式，具有固定的读端和写端；需要双方通信时，需要建立起两个管道。
单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
无名管道的创建——pipe

#include<ubistd.h>
int pipe(int pfd[2]);
1
2
成功时返回0,失败返回EOF
pfd包含两个元素的整形数组，用来保存文件描述符
pfd[0]用于读取管道；pdf[1]用于写管道
注意：无名管道虽然返回了两个文件描述符，但是无名管道不像普通文件具有路径，在文件系统中不可见，仅仅存在在内存中。并且无名管道是某个进程创建的，其他进程要想打开无名管道只能通过继承的方式打开其他进程创建的无名管道。因此，无名管道只能在用亲缘关系的进程间通信。
在这里插入图片描述
上图是父子进程通过无名管道的通信示意图，父进程创建无名管道，返回fd[0]和fd[1]。虽然返回了两个文件描述符但是由于管道是一个单工的通信模式，因此一个进程只能访问一个文件描述符。例如:当父进程读管道时，就只能访问df[0],子进程只能写管道访问df[1]。
示例：
子进程1和子进程2分别往管道中写入字符串；父进程读取管道内容并打印。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
int main()
{
pid_t pid1,pid2;
char buf[32];
int pfd[2];
if(pipe(pfd)<0){
perror(“pipe”);
exit(-1);
}
if((pid1=fork())<0){
perror(“fork”);
exit(-1);
}
else if(pid10)//子进程1
{
strcpy(buf,“I’m process1”);
write(pfd[1],buf,32);
exit(0);
}
else
{
if((pid2=fork())<0){//子进程2
perror(“fork”);
exit(-1);
}
else if(pid20){
sleep(1);
strcpy(buf,“I’m process 2”);
write(pfd[1],buf,32);
printf("%s\n",buf);
}
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
注意：无名管道创建时会返回两个文件描述符，普通的文件读取以后文件内容依旧存在，但是管道中的内容被读取以后内容就不存在。

无名管道的读写特性

写端存在且管道中有数据时，read返回实际读取的字节数。当管道有数据时，读进程阻塞（直到管道中有数据）。
写端不存在且管道中有数据时，read返回实际读取的字节数。当管道无数据时，read返回0。
读端存在且管道有空间时，write返回实际写入的字节数。当管道无空间时，写进程阻塞。
读端不存在不论管道是否有空间进程都会异常结束，会导致管道断裂。系统不允许写一个读端不存在的进程
根据管道的读写特性我们就可以获取管道的大小。通过循环向管道中写入数据，直到写进程阻塞，统计循环的次数就可以很容易计算出管道的大小。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
int count=0,pfd[2];
char buf[1024];
if(pipe(pfd)<0)
{
perror(“pipe”);
exit(-1);
}
while(1)
{
write(pdf[1],buf,1024);
printf(“wrote %dk byte\n”,++count);
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
通过运行以上程序发现，当count为64时不再打印数据，因此可以得出在Linux中管道的大小为64K。

有名管道（fifo）
无名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道(FIFO)。

   有名管道不同于匿名管道之处在于它提供了一个路径名与之关联，以有名管道的文件形式存在于文件系统中。这样即使与有名管道的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过有名管道相互通信，因此，通过有名管道不相关的进程也能交换数据。
   值的注意的是，有名管道严格遵循先进先出(first in first out),对匿名管道及有名管道的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。有名管道的名字存在于文件系统中，内容存放在内存中。

有名管道特点：

对应管道文件，可用于任意进程之间的通信
打开管道时可以指定读写方式
通过文件I/O操作，内容存放在内存中（读端和写端都关闭的时候，存放在内存中的数据就会被释放）
有名管道的创建——mkfifo

#include<unistd.h>
#include<fcntl.h>
int mkfifo(const char *path,mode_t mode);
1
2
3
成功时返回0，失败时返回EOF
path创建的管道文件路径
mode管道文件的权限，如0666
示例：

   进程A：循环从键盘输入并写入有名管道myfifo，输入quit时退出。
   进程B：循环统计进程A每次写入myfifo的字符串的长度。

create_fifo.c内容如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
int main(void)
{
if(mkfifo(“myfifo”,06666)<0){
perror(“mkfifo”);
exit(-1);
}

}
1
2
3
4
5
6
7
8
9
10
11
12
read_fifo.c内容如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#define N 32
int main(void)
{
char buf[N];
int fpd;
if ((fpd = open(“myfifo”,O_WRONLY))<0)
{
perror(“open”);
exit(-1);
}
printf(“myfifo is opened\n”);
while(read(fpd,buf,N)>0){
printf(“thr length of string is %d\n”,strlen(buf));
}
close(fpd);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
write_fifo.c内容如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#define N 32
int main(void)
{
char buf[N];
int fpd;
if ((fpd = open(“myfifo”,O_WRONLY))<0)
{
perror(“open”);
exit(-1);
}
printf(“myfifo is opened\n”);
while(1)
{
fgets(buf,N,stdin);
if(strcmp(buf,“quit\n”)==0)
{
break;
}
write(fpd,buf,N);
}
close(fpd);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
注意：进程打开一个有名管道只有读端或者写端时会导致进程阻塞,只有两个都打开时程序才有意义。

信号机制
信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。Linux内核通过信号通知用户进程，不同的信号类型代表不同的事件。Linux中信号是对早期的unix信号机制进行了扩展。

常用信号

信号名 含义 默认操作
SIGHUB 该信号在用户终端关闭时产生，通常是发给和该终端关联的会话内所有进程 终止
SIGINT 该信号在用户键入INTR字符（Ctrl+C）时产生，内核发送此信号到当前终端的所有前台进程 终止
SIGQUIT 该信号和SIGINT类似，但由QUIT字符（通常是CTRL+\ \）来产生 终止
SIGILL 该信号在一个进程企图执行一条非法指令时产生 终止
SIGSEV 该信号在非法访问内存时产生，如野指针、缓冲区溢出 终止
SIGPIPE 当进程向一个没有读端的管道中写书数据时产生，代表管道断裂 终止
SIGKILL 该进程用来结束进程，并且不能被捕捉和忽略 终止
SIGSTOP 该信号用于暂停进程，并且不能被捕捉和忽略 暂停进程
SIGTSTP 该信号用于暂停进程，用户可以键入SUSP字符（通常是Ctrl-Z）发出这个信号 暂停进程
SIGXONT 该信号让进程进入运行态 继续运行
SIGALRM 该信号用于通知进程定时器时间已到 终止
SIGUSR1/2 该信号保护给用户程序使用 终止
信号相关的命令kill/killall

kill [-signal] pid

默认发送SIGTERM
-sig可指定信号
pid指定发送对象
killall [-u user | prog]

prog 指定进程名
user 指定用户名
信号发送——kill/raise
#include <unistd.h>
#include <signal.h>
int kill(pid_t pid,int sig);
int raise(int sig);

成功时返回0，失败时返回EOF
pid接收进程的进程号；0代表同组进程；-1代表所有进程
sig信号类型
定时器函数——alarm/pause

#include <unistd.h>
#include <signal.h>
int alarm(unsigned int seconds);
1
2
3
成功时返回上个定时器的剩余时间，失败时返回EOF
seconds定时器的时间
一个进程只能设定一个定时器，时间到时产生SIGALARM
#include <unistd.h>
#include <signal.h>
int purse(void);
1
2
3
进程一直阻塞，直到被信号中断
被信号中断后返回-1，erron为EINTR
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
alarm(3);//3秒后进程终止
pause();
printf(“I have been waken up!\n”);
return 0;
}
1
2
3
4
5
6
7
8
9
10
运行以上程序会发现并没有打赢printf里的内容，而是打印的是Alarm clock。这是因为3秒后定时器缺省导致进程结束进而无法继续向下执行。alarm经常用于实现超时检测。

设置信号响应方式——signal

#include <unistd.h>
#include <signal.h>
void(*signal(int signo,void(*handler)(int)))(int);//第二个参数是一个函数指针，存放的是某个函数的入口地址
1
2
3
成功时返回原先的信号处理函数，失败时返回SIG_ERR
signo要设置的信号类型
handler指定的信号处理函数：SIGDFL代表缺省方式；SIG_IGN代表忽略信号；
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
void handler(int signo)
{
if(signoSIGINT)
{
printf(“I have got SIGINT!\n”);
}
if(signoSIGQUIT)
{
printf(“I have got SIGQUIT\n”);
}
}
int main()
{
signal(SIGINT,handler);
signal(SIGQUIT,handler);
while(1) pause();
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
不积小流无以成江河，不积跬步无以至千里。而我想要成为万里羊，就必须坚持学习来获取更多知识，用知识来改变命运，用博客见证成长，用行动证明我在努力。
如果我的博客对你有帮助、如果你喜欢我的博客内容，记得“点赞” “评论” “收藏”一键三连哦！听说点赞的人运气不会太差，每一天都会元气满满呦！如果实在要白嫖的话，那祝你开心每一天，欢迎常来我博客看看。
在这里插入图片描述

点赞
22

评论
5

分享

收藏
16

手机看

打赏

关注
Scenlyf的博客
1346

【Linux】进程间通信之管道
每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信（IPC,InterProcess Com），也就是说进程通信使不同的进程可以看见同一份系统资源。1、管道是一种最基本的IPC机制，由pipe函数来…
涂作权的博客
1615

1pipe管道

原文链接：https://blog.csdn.net/weixin_44895651/article/details/107928228?utm_medium=distribute.pc_feed.none-task-blog-personrec_tag-20.nonecase&depth_1-utm_source=distribute.pc_feed.none-task-blog-personrec_tag-20.nonecase&request_id=5f345eb2df0ade635132398d