创建2个子进程

Create 2 child processes

本文关键字:子进程 2个 创建      更新时间:2023-10-16

我必须在3个进程之间创建这种通信:

  • 1进程(父进程):

    • 向子节点1发送偶数;
    • 向子节点2发送不均匀的数字;
    • 获取子1和子2发送的数字
  • 2个子进程1:

    • 从父节点获得偶数;
    • 向子节点2发送偶数;
    • 发送2*value_of_number给父
  • 3进程(子进程2):

    • 从父端获得不均匀的数字;
    • 发送2*value_of_number给父

这是我的代码:

int main()
{
    int p12[2],p13[2],p23[2];
    int p21[2],p31[2];
    if(pipe(p12)<0){
        perror("pipe 12 errorn");
        exit(1);
    }
    if(pipe(p13)<0){
        perror("pipe 13 errorn");
        exit(1);
    }
    if(pipe(p23)<0){
        perror("pipe 23 errorn");
        exit(1);
    }
    if(pipe(p21)<0){
        perror("pipe 21 errorn");
        exit(1);
    }
    if(pipe(p31)<0){
        perror("pipe 31 errorn");
        exit(1);
    }
    switch(fork()){
        case -1:{
            perror("fork 1 errorn");
            exit(1);
        }
        case 0:{//1 child
            close(p12[1]);
            close(p13[1]);
            close(p13[0]);
            close(p23[0]);
            close(p21[0]);
            close(p31[1]);
            close(p31[0]);
            int paros;
            int ket;
            while(read(p12[0],&paros,sizeof(int))>0){
                cout<<"2: "<<paros<<endl;
                if(write(p23[1],&paros,sizeof(int))==-1){
                    perror("write 23 errorn");
                    exit(1);
                }
                ket=2*paros;
                if(write(p21[1],&ket,sizeof(int))==-1){
                    perror("write 21 errorn");
                    exit(1);
                }
            }
            close(p21[1]);
            close(p12[0]);
            close(p23[1]);
            exit(0);
        }
        default:{
            switch(fork()){
                case -1:{
                    perror("fork 2 errorn");
                    exit(1);
                }
                case 0:{//2 child
                    close(p13[1]);
                    close(p12[1]);
                    close(p12[0]);
                    close(p23[1]);
                    close(p31[0]);
                    close(p21[1]);
                    close(p21[0]);
                    int szamok;
                    int ket;
                    while(read(p13[0],&szamok,sizeof(int))>0){
                        cout<<"3: "<<szamok<<endl;
                        ket=2*szamok;
                        if(write(p31[1],&ket,sizeof(int))==-1){
                            perror("write 31 errorn");
                            exit(1);
                        }
                    }
                    while(read(p23[0],&szamok,sizeof(int))>0){
                        cout<<"3: "<<szamok<<endl;
                    }
                    close(p31[1]);
                    close(p13[0]);
                    close(p23[0]);
                    exit(0);
                }
                default:{
                    close(p12[0]);
                    close(p13[0]);
                    close(p23[0]);
                    close(p23[1]);
                    close(p21[1]);
                    close(p31[1]);
                }
            }
        }
    }
    int i=1;
    while(i<=10){
        if(i%2==0){
            if(write(p12[1],&i,sizeof(int))==-1){
                perror("write 12 errorn");
                exit(1);
            }
        }
        else{
            if(write(p13[1],&i,sizeof(int))==-1){
                perror("write 13 errorn");
                exit(1);
            }
        }
        i++;
    }
    int szam;
    while(read(p21[0],&szam,sizeof(int))>0){
        cout<<"1: "<<szam<<endl;
    }
    while(read(p31[0],&szam,sizeof(int))>0){
        cout<<"1: "<<szam<<endl;
    }
    close(p12[1]);
    close(p13[1]);
    close(p31[0]);
    close(p21[0]);
    while(wait(NULL)>0){};
    exit(0);
}

父进程在每个管道中写入5个数字,然后等待子进程1的所有响应,然后再转到子进程2。在给子进程写完数字之后,你不会关闭这些管道,所以那些子进程不知道父进程已经停止了。在子进程1的情况下,它仍在等待从父进程接收更多的数字。正因为如此,它永远不会关闭自己的管道并退出。因此,父进程被卡在它从子进程1开始的第一个读循环中,永远无法到达子进程2。

在写入p12[1]和p13[1]后,加入

close(p12[1]);
close(p13[1]);

,过程将运行到完成