问一个关于fork后的文件操作的IO问题

liuzhuan23

代码如下（一个父进程，fork了100个子进程，每个子进程共享父进程打开的文件描述符，每个子进程写入1000个字符，基本的逻辑过程就是这样）

为什么在程序exit后，文件中，没有存入100*1000个字符？

如果将子进程数量增多，或者字符数增加，那么，文件中的字符数就更匹配不上了

很纳闷这个问题，坛子里的朋友有兴趣可以看一看，呵呵

1. #include <stdio.h>
   
2. #include <fcntl.h>
   
3. 
   
4. int main()
   
5. {
   
6. struct flock stF;
   
7. int i,n,fd,pid;
   
8. 
   
9. fd=open("./output.txt",O_RDWR|O_CREAT);
   
10. 
    
11. for(i=0;i<99;i++)
    
12. {
    
13.         pid=fork();
    
14. 
    
15.         if(pid==-1)
    
16.         {
    
17.                 perror("fork:");
    
18.         }
    
19.         else if( pid > 0 )
    
20.         {
    
21.                 break;
    
22.         }
    
23. }
    
24. 
    
25. stF.l_type=F_WRLCK;
    
26. stF.l_start=0;
    
27. stF.l_whence=SEEK_SET;
    
28. stF.l_len=0;
    
29. 
    
30. for(i=0;i<999;i++)
    
31. {
    
32.         if(fcntl(fd,F_SETLKW,&stF)==-1)
    
33.         {
    
34.                 perror("lock:");
    
35.         }
    
36. 
    
37.         lseek(fd,0,SEEK_END);
    
38.         if(write(fd,"1",1)!=1)
    
39.         {
    
40.                 perror("write:");
    
41.         }
    
42. 
    
43.         stF.l_type=F_UNLCK;
    
44.         if(fcntl(fd,F_SETLKW,&stF)==-1)
    
45.         {
    
46.                 perror("unlock:");
    
47.         }
    
48. }
    
49. 
    
50. close(fd);
    
51. }
    

复制代码

liuzhuan23

回复 2# 七月已过


    呵呵，没事，都是新手过来的

vincentff7

不懂
UP一下

whaaat

这是每个进程写入999个字符吧

liuzhuan23

不管是99还是100，最终的字符总数量差距很大，不是循环计数器的问题，那个可以随时调整

MMMIX

我寫了一個：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <sys/stat.h>
   
6. #include <fcntl.h>
   
7. 
   
8. #define CNT 10
   
9. 
   
10. void write_file(int fd, char data, size_t len);
    
11. 
    
12. int main(int argc, char *argv[])
    
13. {
    
14.         char *fn;
    
15.         int fd;
    
16.         pid_t pid;
    
17. 
    
18.         if (argc > 1)
    
19.                 fn = argv[1];
    
20.         else
    
21.                 fn = "flock-demo";
    
22. 
    
23.         if ((fd = open(fn, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) {
    
24.                 perror("open:");
    
25.                 exit(-1);
    
26.         }
    
27. 
    
28.         for (int i = 0; i < CNT; i++) {
    
29.                 if ((pid = fork()) < 0) {
    
30.                         perror("fork:");
    
31.                         exit(-1);
    
32.                 } else {
    
33.                         if (pid == 0) {
    
34.                                 /* child process */
    
35.                                 write_file(fd, i, sizeof(i));
    
36.                                 exit(0);
    
37.                         }
    
38.                 }
    
39.         }
    
40. 
    
41.         return 0;
    
42. }
    
43. 
    
44. void write_file(int fd, char data, size_t len)
    
45. {
    
46.         struct flock fl;
    
47. 
    
48.         /* lock the whole file */
    
49.         fl.l_whence = SEEK_SET;
    
50.         fl.l_start  = 0;
    
51.         fl.l_len    = 0;
    
52. 
    
53.         for (int i = 0; i < CNT; i++) {
    
54.                 fl.l_type = F_WRLCK;
    
55.                 if (fcntl(fd, F_SETLKW, &fl) < 0) {
    
56.                         perror("fcntl:");
    
57.                         exit(-1);
    
58.                 }
    
59. 
    
60.                 ssize_t wlen = write(fd, &data, len);
    
61.                 if (wlen < 0) {
    
62.                         perror("write:");
    
63.                         exit(-1);
    
64.                 } else {
    
65.                         if ((size_t)wlen < len) {
    
66.                                 fprintf(stderr, "Other write error in process %d\n", getpid());
    
67.                                 exit(-1);
    
68.                         }
    
69.                 }
    
70. 
    
71.                 fl.l_type = F_UNLCK;
    
72.                 if (fcntl(fd, F_SETLKW, &fl) < 0) {
    
73.                         perror("fcntl:");
    
74.                         exit(-1);
    
75.                 }
    
76.         }
    
77. }
    

复制代码

查看結果：

1. 
   
2. lee@debian:~/tmp/C$ gcc -std=c99 flock.c
   
3. lee@debian:~/tmp/C$ ./a.out
   
4. lee@debian:~/tmp/C$ od -A d -w40 -t xI -v flock-demo
   
5. 0000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
   
6. 0000040 00000001 00000001 00000001 00000001 00000001 00000001 00000001 00000001 00000001 00000001
   
7. 0000080 00000002 00000002 00000002 00000002 00000002 00000002 00000002 00000002 00000002 00000002
   
8. 0000120 00000003 00000003 00000003 00000003 00000003 00000003 00000003 00000003 00000003 00000003
   
9. 0000160 00000004 00000004 00000004 00000004 00000004 00000004 00000004 00000004 00000004 00000004
   
10. 0000200 00000005 00000005 00000005 00000005 00000005 00000005 00000005 00000005 00000005 00000005
    
11. 0000240 00000006 00000006 00000006 00000006 00000006 00000006 00000006 00000006 00000006 00000006
    
12. 0000280 00000007 00000007 00000007 00000007 00000007 00000007 00000007 00000007 00000007 00000007
    
13. 0000320 00000008 00000008 00000008 00000008 00000008 00000008 00000008 00000008 00000008 00000008
    
14. 0000360 00000009 00000009 00000009 00000009 00000009 00000009 00000009 00000009 00000009 00000009
    
15. 0000400
    

复制代码

若要各個子進程的輸出不互相穿插，則需要把加鎖放在子進程輸出循環的外面。

vincentff7

回复 7# MMMIX


    查了下资料，记录锁是排队的FIFO队列。但为什么会出现楼主说的这种结果？

hohoss

回复 7# MMMIX


学习了，代码很严谨

hohoss

回复  MMMIX


    查了下资料，记录锁是排队的FIFO队列。但为什么会出现楼主说的这种结果？
vincentff7 发表于 2011-08-21 13:53

楼主的问题不是出在记录锁问题，而是子进程互相做了其他进程地址空间的副本，
并且在for....for()中，父进程有个break -__-，导致进程分配不足。。。
并且struct flock来回更改，导致混乱。。。。


我是初学者，有错误的话还请指正。。。。

rd1chenqiang

LZ 代码写得还是好乱。。 呵呵