用FIFO编写的进程之间通信的程序，可是有错误，请高手指教

u5

下面是我用FIFO写的子进程间通信的程序，主要实现先创建子进程1，执行完之后发信号给父进程，父进程再创建子进程2，然后实现2者之间的通信。但运行结果是could not open fifo,这是为什么呢？是不是子进程1结束了，就不能实现通信啦？请问错在哪里？

1. #include<stdio.h>;
   
2. #include<stdlib.h>;
   
3. #include<fcntl.h>;
   
4. #include<sys/types.h>;
   
5. #include<sys/stat.h>;
   
6. #include<limits.h>;
   
7. #include<unistd.h>;
   
8. #include"err_exit.h"
   
9. #define FIFO_FILE "myfifo"
   
10. 
    
11. static pid_t child_id[1];
    
12. static int myfifo1(void);
    
13. static int myfifo2(void);
    
14. static int fifo_fd,n;
    
15. static char buffer[BUFSIZ+1];
    
16. static char some_data[]="hello,world!";
    
17. void sig_usr(int signo)/*信号SIGUSR1的句柄*/
    
18. {   
    
19.    
    
20.         printf("received SIGUSR1 \n");
    
21.            /*创建新的子进程2*/
    
22.            child_id[1]=fork();
    
23.            if(child_id[1]==0)
    
24.               {  
    
25.             /*自己定义的进程通信函数*/
    
26.                       myfifo1();
    
27.                       myfifo2();                     
    
28.                 /*子进程2的功能*/
    
29.                       child_function2();                     
    
30.       
    
31.                 exit(0);
    
32.               }
    
33.            else if(child_id[1]<0)
    
34.                printf("fork error.");               
    
35. }
    
36. 
    
37. /*子进程执行此函数*/
    
38. int child_function1()
    
39. {
    
40.       printf("this is child1:\n");
    
41.       printf("done1.\n");
    
42.       /*发出信号通知父进程子进程1已完成*/
    
43.       kill(getppid(),SIGUSR1);
    
44.       exit(EXIT_SUCCESS);
    
45.       return 0;
    
46. }
    
47. 
    
48. int  child_function2()
    
49. {     
    
50.       printf("this is child2:\n");
    
51.       printf("Done2.\n");
    
52.       exit(EXIT_SUCCESS);
    
53.       return 0;
    
54. }
    
55. 
    
56. int main(int argc, char *argv[])
    
57. {   
    
58.                
    
59.       int i;
    
60.       int status;     
    
61.       struct sigaction usr_action;
    
62.       sigset_t block_mask;
    
63.       /*初始化信号句柄*/
    
64.       sigfillset(&block_mask);
    
65.       usr_action.sa_handler=sig_usr;/*指定与信号相关连的动作*/
    
66.       usr_action.sa_mask=block_mask;
    
67.       usr_action.sa_flags=0;
    
68.       /*为信号SIGUSR1*/
    
69.       sigaction(SIGUSR1,&usr_action,NULL);   
    
70.            
    
71.                         
    
72.       /*创建子进程1*/  
    
73.       child_id[0]=fork();
    
74.       if(child_id[0]==0)
    
75.           { child_function1();  
    
76.             exit(0); }  
    
77.       else if(child_id[0]<0)
    
78.           printf("fork error.");                                                               
    
79.                   
    
80.       /*父进程*/
    
81.       for(i=0;i<2;i++)
    
82.          waitpid(child_id[i],&status,0);
    
83.       printf("data sending is over.\n");
    
84.       exit(EXIT_SUCCESS);
    
85. }
    
86. int myfifo2(void)
    
87. {
    
88.      
    
89.      if(access(FIFO_FILE,F_OK)==-1)
    
90.          {  if(mkfifo(FIFO_FILE,0666)!=0)
    
91.               {
    
92.                       printf("could not create fifo %s\n",FIFO_FILE);
    
93.                       exit(EXIT_FAILURE);
    
94.               }
    
95.          }
    
96.       if((fifo_fd=open(FIFO_FILE,O_RDONLY))<0)
    
97.          {
    
98.              printf("could not open fifo %s\n",FIFO_FILE);
    
99.              exit(EXIT_FAILURE);
    
100.          }       
     
101.        printf("child2 %d opened:%s\n",getpid(),FIFO_FILE);
     
102.        while((n=read(fifo_fd,buffer,BUFSIZ))>;0)
     
103.               printf("child2 %d received %d bytes:%s\n",getpid(),n,buffer);
     
104.        close(fifo_fd);
     
105.        printf("child2 %d received %d bytes then finished\n",getpid(),n);
     
106.        return 0;
     
107. }
     
108. int myfifo1(void)
     
109. {
     
110.      int fifo_fd,n;
     
111.      char buffer[BUFSIZ+1];
     
112.      char some_data[]="hello,world!";
     
113.      if((fifo_fd=open(FIFO_FILE,O_WRONLY))<0)
     
114.          {
     
115.                  printf("could not open fifo %s\n",FIFO_FILE);
     
116.                  exit(EXIT_FAILURE);
     
117.          }
     
118.      printf("child1 %d opened:%s\n",getpid(),FIFO_FILE);
     
119.      if(n=write(fifo_fd,some_data,strlen(some_data))==-1)
     
120.               err_exit("FIFO broken");
     
121.      printf("child1 %d write %d bytes\n",getpid(),n);
     
122.      close(fifo_fd);
     
123.      printf("child1 %d write %d bytes then finished\n",getpid(),n);
     
124.      return 0;
     
125. }
     
126.       
     
127.      

复制代码

蓝色键盘

我没看你的代码，倒是看到了你如下的一句话：
“是不是子进程1结束了，就不能实现通信啦？”

因为FIFO是process persistent，所以如果两个相互通讯的进程中一个结束了（包括正常结束如exit，和异常结束如接受到信号）,那么这个FIFO结束了的相关进程的一个端不可用，对于程序设计者而言，看到的现象便是不通讯了。

u5

那我要实现子进程2是在子进程1发信号之后创建，而1还要传一个字符串给2应该怎么办呢？
是不是2个并行的子进程就可以啦？

蓝色键盘

只要保证2能够找到这个有名管道的一个端读写（另一段由1读写）便可以了。你用两个子进程也可以。但是子进程不是并发的。并发是给你的感觉是这样。事实上1和2根本不可能并发的（在单CPU的环境中）。

u5

它们好像是抢占时间片，所以每次执行的顺序都是随机的，是吗？

只要保证2能够找到这个有名管道的一个端读写（另一段由1读写）便可以了。

这句话我不是很懂？能不能说具体点，谢谢啦

蓝色键盘

其实说得通俗一点，就是保证这两个进程操作的是一个FIFO。呵呵

看来，我写的书一定会苦涩难懂！

u5

这句话我懂啦
     斑竹你那么热心帮助我们解决困惑，帮我们提供学习资料，我们都很感谢你
   以后出书了别忘了告诉我们一声，我们一定帮你作宣传提高销售量，再买几本作为收藏啦

蓝色键盘

拷，我是大比方，写书估计这辈子论不到我了。不论是什么书。