linux实验多进程,Linux开发简单多进程应用

一个进程中的多个线程共享一个进程的堆等内存空间，所以实现数据交互是很方便的；但多进程架构中，要想实现多进程间的数据交互相对就困难很多！

进程间通信(IPC，InterProcess Communication)是指在不同进程之间传递或交换信息。IPC常见的方式有：管道(无名管道、命名管道)、消息队列、信号量、共享内存、磁盘文件、Socket等，其中Socket网络方式可以实现不同主机上的多进程IPC

一个带坑的小例子

下面使用fork()、pipe()实现一个简单的Linux平台下的多进程、多进程通信的程序

#include

#include

#include

int main()

{

int pipefd[2]; //两个文件描述符

pid_t pid;

char buff[20];

int i;

//创建管道

if(0 > pipe(pipefd)){

printf("Create Pipe Error!\n");

}

//创建2个子进程

for(i=0; i<2; i++){

pid = fork();

if((pid_t)0 >= pid){

sleep(1);

break;

}

}

//如果fork返回值小于0，说明创建子进程失败

if((pid_t)0 > pid){

printf("Fork Error!\n");

return 3;

}

//如果fork返回值为0，表示进入子进程的逻辑

if((pid_t)0 == pid){

//发送格式化数据给主进程

FILE *f;

f = fdopen(pipefd[1], "w");

fprintf(f, "I am %d\n", getpid());

fclose(f);

sleep(1);

//接收父进程发过来的数据

read(pipefd[0], buff, 20);

printf("MyPid:%d, Message:%s", getpid(), buff);

}

//进入父进程的逻辑

else{

//循环接收所有子进程发过来的数据，并且返回数据给子进程

for(i=0; i<2; i++){

//接收子进程发来的数据

read(pipefd[0], buff, 20);

printf("MyPid:%d, Message:%s", getpid(), buff);

//发送数据给子进程

write(pipefd[1], "Hello My Son\n", 14);

}

//这里调用sleep(3)主要的作用是等待子进程运行结束

//当然这样并不是很规范！

sleep(3);

}

return 0;

}

编译程序gcc process.c -o process，然后执行./process输入信息如下

但我们可以发现输出的内容有一些异常，比如第二行最开始怎么有一个@字符、最后一行明显丢失了一些字符信息等

上面的程序还不止是输出不符合预期这个表面的问题，还存在诸多的坑，都是因为一开始对于多进程、管道的深入机制理解不正确造成的！

下面针对Linux的管道进行比较深入的挖掘，就可以发现上面的小程序中存在很多的坑

管道是阻塞的

管道读写是阻塞的，当管道中没有数据，但进程尝试去读的时候就会阻塞进程，比如

#include

#include

#include

int main()

{

int pipefd[2];

pid_t pid;

char buff[20];

int i;

if(0 > pipe(pipefd)){

printf("Create Pipe Error!\n");

}

pid = fork();

if((pid_t)0 > pid){

printf("Fork Error!\n");

return 3;

}

if((pid_t)0 == pid){

//write(pipefd[1], "Hello\n", 6);

}

else{

read(pipefd[0], buff, 20);

printf("MyPid:%d, Message:%s", getpid(), buff);

}

return 0;

}

其运行效果如下，可以看到主进程阻塞住了

可以修改让子进程往管道中写入数据，主进程再去读，这样就不会阻塞了

#include

#include

#include

int main()

{

int pipefd[2];

pid_t pid;

char buff[20];

int i;

if(0 > pipe(pipefd)){

printf("Create Pipe Error!\n");

}

pid = fork();

if((pid_t)0 > pid){

printf("Fork Error!\n");

return 3;

}

if((pid_t)0 == pid){

}

else{

read(pipefd[0], buff, 20);

printf("MyPid:%d, Message:%s", getpid(), buff);

}

return 0;

}

运行程序可以看到主进程没有阻塞

管道是半双工的

所谓半双工，意思就是只能在一个方向上传递数据，对于pipe，只能从pipe[1]写，从pipe[0]读，只能在一个方向传递数据；可以结合socket来理解，socket是全双工的，也就是针对一个socket既可以写又可以读

第一个例程中创建了一个管道，但却希望通过这个管道实现主进程传递数据给子进程、子进程传递数据给主进程，完全是想在两个方向传递数据，结果导致主进程和2个子进程同时既往管道里写，又从管道里读，所以出现了上述诡异的现象

比如下面这个例子，创建一个管道，但不创建子进程，可以在主进程既写又读管道！

#include

#include

#include

int main()

{

int pipefd[2];

pid_t pid;

char buff[20];

int i;

if(0 > pipe(pipefd)){

printf("Create Pipe Error!\n");

}

write(pipefd[1], "Hello\n", 6);

read(pipefd[0], buff, 20);

printf("MyPid:%d, Message:%s", getpid(), buff);

return 0;

}

因为管道是半双工的，所以要想在保证数据不乱的情况下，不能在多进程应用中只使用一个管道，需要一套管道，有的是数据从主进程到子进程，有的是数据从子进程到主进程

完善后的程序

#include

#include

#include

int main()

{

//管道1,用于子进程发送数据给主进程

int pipefd[2];

//管道数组2,用于主进程分别发数据给子进程

int pipearr[3][5];

pid_t pid;

char buff[20];

int i;

//创建管道

if(0 > pipe(pipefd)){

printf("Create Pipe Error!\n");

}

for(i=0; i<3; i++){

if(0 > pipe(pipearr[i])){

printf("Create Pipe Error!\n");

}

}

//创建3个子进程

for(i=0; i<3; i++){

pid = fork();

//创建子进程失败

if((pid_t)0 > pid){

printf("Fork Error!\n");

return 3;

}

//子进程逻辑

if((pid_t)0 == pid){

//发送格式化数据给主进程

FILE *f;

f = fdopen(pipefd[1], "w");

fprintf(f, "I am %d\n", getpid());

fclose(f);

//接收父进程发过来的数据

read(pipearr[i][0], buff, 20);

printf("MyPid:%d, Message:%s", getpid(), buff);

//完成后及时退出循环，继续循环会出大问题，和fork的运行逻辑有关！

break;

}

}

//主进程逻辑

if((pid_t)0 < pid){

//循环接收所有子进程发过来的数据，并且返回数据给子进程

for(i=0; i<3; i++){

//接收子进程发来的数据

read(pipefd[0], buff, 20);

printf("MyPid:%d, Message:%s", getpid(), buff);

//发送数据给子进程

write(pipearr[i][6], "Hello My Son\n", 14);

}

sleep(3);

}

return 0;

}

编译后的运行效果如下：

简单说一下上面的程序逻辑：

首先是有两种管道

第一种只有一个：创建的3个子进程都往这里面写，主进程从这里面读取数据

第二种有一组，每个子进程一个：主进程分别往3个管道中写，每个子进程对应从属于自己的管道中读

针对第二种，很明显一个写，一个读，可以保证并发安全。但第一种呢，多个子进程都往一个管道里面写，会不会有问题，这个需要特别注意：

当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性

当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性

上面多个子进程同时往pipefd中写入的数据小于PIPE_BUF，所以是原子性的，另外只有主进程一个进程在读，所以可以保证数据的完整性。在webbench中其实就是这样使用管道的

可以编译下面的程序，查看PIPE_BUF的值

#include

#include

int main()

{

printf("PIPE_BUF = %d\n", PIPE_BUF);

return 0;

}

编译后运行效果如下：