进程间通信包括本地进程间通信和网络进程间通信
-
网络进程间通信：不同计算机的进程间通信，是基于socket进程的通信
-
本地进程间通信：同一台计算机系统中各进程间的通信，包括下面五种
【Linux下的各种进程间通信方式】
- 管道
- 命名管道
- 消息队列
- 共享内存
- 信号量
【1】管道
（1）概述
-
管道实现数据以数据流的方式在进程间流动。在系统中其相当于文件系统上的一个文件，来缓存所要传输的数据。
-
在某些特性上又不同于文件，例如，当数据读出后，则管道中就没有数据了，但文件没有这个特性。
-
顾名思义，匿名管道在系统中没有实名，并不可以在文件系统中以任何方式看到该管道。它只是进程的一种资源，会随着进程的结束而被系统清除。
-
创建一个管道时生成了两个文件描述符，但对于管道中所使用的文件描述符并没有路径名，也就是不存在任何意义上的文件，它们只是在内存中跟某一个索引节点相关联的两个文件描述符
-
shell中，经常使用(l)来连接两个甚至多个命令
（2）管道的创建
Linux下使用pipe函数创建一个匿名管道，函数原型如下：
#include <unistd.h>
int pipe(int fd[2]);
返回: 成功返回0，出错返回-1
fd[2]：长度为2的文件描述符数组
- fd[0]是读出端的文件描述符
- fd[1]是写入端的文件描述符
- 当函数成功返回后，则自动维护了一个从fd[1]到fd[0]的数据通道
（3）管道的关闭
管道的关闭使用的是基于文件描述符close函数。
（4）一个使用管道的例子，create_pipe.c:
程序中先使用函数pipe建立管道，并使用管道传输数据，在程序结束部分，释放掉管道占用的文件资源(两个文件描述符)
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int fd[2];/*管道的文件描述符数组*/
char str[256];
if((pipe(fd)) < 0)
{
printf("create the pipe failed!
");
exit(1);/*出错退出*/
}
write(fd[1],"create the pipe successfully!
",31);
/*向管道写入端写入数据*/
read(fd[0],str,sizeof(str));
/*从管道输出端读出数据*/
printf("%s",str);
printf("pipe file description are %d , %d
",fd[0],fd[1]);
close(fd[0]);
close(fd[1]);
return 0;
}
运行结果：
hyx@hyx-virtual-machine:~/test$ ./create_pipe
create the pipe successfully!
pipe file description are 3 , 4
（5）管道的读写
使用read和write对管道进行操作
- 管道读取规则：
(1)如果管道写端不存在，则认为读到了数据末尾，读函数返回的读出字节数为0
(2)写端存在时，
- 若请求字节数 > PIPE_BUF，则返回管道中现有的数据字节数
（PIPE_BUF在include/linux/limits.h中定义）
- 若请求字节数 < PIPE_BUF，则返回管道中现有数据字节数(此时管道中数据量小于请求数据量)
或返回请求字节数(此时管道中数据量不小于请求数据量)
- 管道写入规则：
- 管道缓冲区一旦有空闲区域，写进程就会立即试图向管道写入数据，如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞
(6)管道在父子进程中的应用
parent _ pipe _ child.c (使用pipe和fork组合实现父子进程通信)
先使用pipe函数建立管道，再使用fork函数创建子进程
在父子进程中维护管道的数据方向，并在父进程中向子进程发送消息，在子进程中接收消息并输出到标准输出
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <limits.h>
#define BUFSIZE PIPE_BUF /*管道默认一次性读写的数据长度*/
void err_quit(char *msg)
{
printf(msg);
exit(1);
}
int main(void)
{
int fd[2];
char buf[BUFSIZE] = "hello my child!
";/*写入管道的缓冲区*/
pid_t pid;/*定义进程ID的变量*/
int len;
if((pipe(fd)) < 0)/*创建管道*/
err_quit("pipe failed
");
if((pid = fork()) < 0)/*创建一个子进程*/
err_quit("fork failed
");
else if(pid > 0)
{
close(fd[0]);/*父进程中关闭管道的读出端*/
write(fd[1],buf,strlen(buf));
exit(0);
}
else
{
close(fd[1]);/*子进程中关闭管道的写入端*/
len = read(fd[0],buf,BUFSIZE);/*子进程从管道中读出数据*/
if(len < 0)
err_quit("process failed when read a pipe
");
else
write(STDOUT_FILENO,buf,len);/*输出到标准输出*/
exit(0);
}
}
hyx@hyx-virtual-machine:~/test$ hello my child!
(7)管道在兄弟进程间的应用
brother_pipe.c：
-
管道在兄弟进程间应用时，应该先在父进程中建立管道，然后调用fork函数创建两个子进程，在兄弟子进程中维护管道的数据方向
-
在父进程中创建管道，并使用fork函数创建2个子进程。在第一个子进程中发送消息到第2个子进程，第2个子进程读出消息并处理。在父进程中，由于并不使用管道通信，所以什么都不做，直接关闭了管道的两端并退出
-
创建第一个子进程时，并没有关闭管道的两端，创建第二个子进程时，关闭了管道
-
创建第二个子进程时，子进程可以继承存活的管道，而不是一个两端已经关闭的管道，否则下面的读操作无法完成
#include <stdlib.h> #include <unistd.h> #include <stdio.h> #include <sys/types.h> #include <limits.h> #define BUFSIZE PIPE_BUF /*管道默认一次性读写的数据长度*/ void err_quit(char *msg) { printf(msg); exit(1); } int main(void) { int fd[2]; char buf[BUFSIZE] = "hello my brother! ";/*缓冲区*/ pid_t pid; int len; if((pipe(fd)) < 0) /*创建管道*/ err_quit("pipe failed "); if((fork()) < 0) /*创建第一个子进程*/ err_quit("fork failed "); else if(pid = 0) /*子进程中*/ { close(fd[0]); /*关闭不使用的文件描述符*/ write(fd[1],buf,strlen(buf));/*写入消息*/ exit(0); } if((pid = fork()) < 0) err_quit("fork failed "); else if(pid > 0) /*父进程中*/ { close(fd[0]); close(fd[1]); exit(0); } else /*第二个子进程中*/ { close(fd[1]); /*关闭不使用的文件描述符*/ len = read(fd[0],buf,BUFSIZE);/*读取消息*/ write("STDOUT_FILENO,buf,len");/*将消息输出到标准输出*/ exit(0); } return 0; }
【2】命名管道
（1）概述
-
命名管道（named pipe）也称为FIFO，它是一种文件类型，创建一个FIFO文件类似于创建一个普通文件
-
FIFO解决了只有具有亲缘关系的进程间才能通信。FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存放于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间），因此，通过FIFO不相关的进程也能交换数据。
命名管道区别于管道主要是以下两点：
-
命名管道可以用于任何两个进程间的通信，而并不限制这两个进程同源，因此命名管道的使用比管道的使用要方便灵活
-
命名管道作为一种特殊的文件存放于文件系统中，而不是像管道一样存放于内存（使用完毕后消失）。当进程对命名管道的使用结束后，命名管道依然存在于文件系统中，除非对其进行删除操作，否则该命名管道不会消失
(2)FIFO管道通过mkfifo创建，函数原型：
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname,mode_t mode);
返回：成功返回0，出错返回-1
第一个参数是一个普通的路径名，即创建后FIFO文件的名字
第二个参数与打开普通文件的open()函数中的mode参数相同
如果mkfifo第一个参数是一个已经存在的路径名时，则返回EEXIST错误，所以般典型的调用代码首先会检查是否返回该错误，如果确实返回该错误，那么只要调用打开FIFO的函数就可以了。一般文件的I/O函数都可以用FIFO,如closeread、write等
(3)关于FIFO的程序示例
create_FIFO.c
演示了如何使用mkfifo创建一个FIFO
-
程序中从命令行参数中得到一个文件名，然后使用mkfifo函数创建FIFO文件。新创建的FIFO只具有读写权限。由于FIFO文件的特性，所以它被隐性地规定不具有执行权限。
#include <sys/types.h> #include <sys/stat.h> #include <errno.h> #include <stdio.h> #include <stdlib.h> int main(int argc,char *argv[]) { mode_t mode = 0666; if(argc != 2) { printf("USEMSG:Create_FIFO{FIFO name} "); exit(1); } if((mkfifo(argv[1],mode)) < 0) { perror("failed to mkfifo! "); exit(1); } else { printf("you successfully create a FIFO name is:%s ",argv[1]); } return 0; } 运行结果： hyx@hyx-virtual-machine:~/test$ ./create_FIFO USEMSG:Create _FIFO{FIFO name} hyx@hyx-virtual-machine:~/test$ ./create_FIFO testfifo you successful create a FIFO name is : testfifo hyx@hyx-virtual-machine:~/test$
(4)命名管道的读写
- 与普通文件类似，可以使用系统调用open打开一个命名管道，使用read和write函数对命名管道进行读写，使用close关闭一个命名管道
(5)使用FIFO进行两个进程间通信的例子
write_fifo.c和read_fifo.c
-
在程序write_fifo.c中打开一个名为fifo1的FIFO文件，并分10次向这个FIFO中写入数据。在程序read_fifo.c中先打开fifo1文件，然后读取里面的数据并输出到标准输出。
-
运行程序时，要先使用 mkfifo -m 666 fifo1 创建fifo1文件
-
因为分别进行读和写，所以在两个shell中进行
write_fifo.c
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <fcntl.h>
#define BUFES PIPE_BUF
int main(void)
{
int fd;
int n,i;
char buf[BUFES];
time_t tp;
printf("I am %d
",getpid());
if((fd = open("fifo1",O_WRONLY)) < 0)
{
printf("Open failed!
");
exit(1);
}
for(i = 0;i < 10;i++)
{
time(&tp);/*提取系统当前时间*/
n = sprintf(buf,"write_fifo %d sends %s",getpid(),ctime(&tp));/*使用sprintf函数向buf中格式化写入进程ID和时间值*/
printf("send msg:%s
",buf);
if((write(fd,buf,n+1)) < 0)
{/*写入到FIFO中*/
printf("write failed!
");
close(fd);/*关闭FIFO文件*/
exit(1);
}
sleep(3);/*进程睡眠3秒，便于观察*/
}
close(fd);/*关闭FIFO文件*/
exit(0);
}
read_fifo.c
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <fcntl.h>
#define BUFES PIPE_BUF
int main(void)
{
int fd;
int len;
char buf[BUFES];
mode_t mode = 0666; /*FIFO文件的权限*/
if((fd=open("fifo1",O_RDONLY)) < 0)/*打开FIFO文件*/
{
printf("open failed!
");
exit(1);
}
while((len = read(fd,buf,BUFES)) > 0)/*开始进行通信*/
printf("read_fifo read:%s",buf);
close(fd);/*关闭FIFO文件*/
exit(0);
}
运行结果：
hyx@hyx-virtual-machine:~/test$ mkfifo -m 666 fifo1
hyx@hyx-virtual-machine:~/test$ ./write_fifo
I am 2964
send msg:write_fifo 2964 sends Thu Dec 3 16:29:26 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:29 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:32 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:35 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:38 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:41 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:44 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:47 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:50 2015
send msg:write_fifo 2964 sends Thu Dec 3 16:29:53 2015
hyx@hyx-virtual-machine:~/test$ ./read_fifo
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:26 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:29 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:32 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:35 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:38 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:41 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:44 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:47 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:50 2015
read_fifo read:write_fifo 2964 sends Thu Dec 3 16:29:53 2015