liuzhuan23 发表于 2011-08-19 15:26

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

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

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

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

很纳闷这个问题,坛子里的朋友有兴趣可以看一看,呵呵#include <stdio.h>
#include <fcntl.h>

int main()
{
struct flock stF;
int i,n,fd,pid;

fd=open("./output.txt",O_RDWR|O_CREAT);

for(i=0;i<99;i++)
{
        pid=fork();

        if(pid==-1)
        {
                perror("fork:");
        }
        else if( pid > 0 )
        {
                break;
        }
}

stF.l_type=F_WRLCK;
stF.l_start=0;
stF.l_whence=SEEK_SET;
stF.l_len=0;

for(i=0;i<999;i++)
{
        if(fcntl(fd,F_SETLKW,&stF)==-1)
        {
                perror("lock:");
        }

        lseek(fd,0,SEEK_END);
        if(write(fd,"1",1)!=1)
        {
                perror("write:");
        }

        stF.l_type=F_UNLCK;
        if(fcntl(fd,F_SETLKW,&stF)==-1)
        {
                perror("unlock:");
        }
}

close(fd);
}

liuzhuan23 发表于 2011-08-19 16:28

回复 2# 七月已过


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

vincentff7 发表于 2011-08-19 16:52

不懂
UP一下:lol:

whaaat 发表于 2011-08-19 17:20

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

liuzhuan23 发表于 2011-08-19 23:07

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

MMMIX 发表于 2011-08-19 23:57

我寫了一個:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

#define CNT 10

void write_file(int fd, char data, size_t len);

int main(int argc, char *argv[])
{
        char *fn;
        int fd;
        pid_t pid;

        if (argc > 1)
                fn = argv;
        else
                fn = "flock-demo";

        if ((fd = open(fn, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) {
                perror("open:");
                exit(-1);
        }

        for (int i = 0; i < CNT; i++) {
                if ((pid = fork()) < 0) {
                        perror("fork:");
                        exit(-1);
                } else {
                        if (pid == 0) {
                                /* child process */
                                write_file(fd, i, sizeof(i));
                                exit(0);
                        }
                }
        }

        return 0;
}

void write_file(int fd, char data, size_t len)
{
        struct flock fl;

        /* lock the whole file */
        fl.l_whence = SEEK_SET;
        fl.l_start= 0;
        fl.l_len    = 0;

        for (int i = 0; i < CNT; i++) {
                fl.l_type = F_WRLCK;
                if (fcntl(fd, F_SETLKW, &fl) < 0) {
                        perror("fcntl:");
                        exit(-1);
                }

                ssize_t wlen = write(fd, &data, len);
                if (wlen < 0) {
                        perror("write:");
                        exit(-1);
                } else {
                        if ((size_t)wlen < len) {
                                fprintf(stderr, "Other write error in process %d\n", getpid());
                                exit(-1);
                        }
                }

                fl.l_type = F_UNLCK;
                if (fcntl(fd, F_SETLKW, &fl) < 0) {
                        perror("fcntl:");
                        exit(-1);
                }
        }
}
查看結果:
lee@debian:~/tmp/C$ gcc -std=c99 flock.c
lee@debian:~/tmp/C$ ./a.out
lee@debian:~/tmp/C$ od -A d -w40 -t xI -v flock-demo
0000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
0000040 00000001 00000001 00000001 00000001 00000001 00000001 00000001 00000001 00000001 00000001
0000080 00000002 00000002 00000002 00000002 00000002 00000002 00000002 00000002 00000002 00000002
0000120 00000003 00000003 00000003 00000003 00000003 00000003 00000003 00000003 00000003 00000003
0000160 00000004 00000004 00000004 00000004 00000004 00000004 00000004 00000004 00000004 00000004
0000200 00000005 00000005 00000005 00000005 00000005 00000005 00000005 00000005 00000005 00000005
0000240 00000006 00000006 00000006 00000006 00000006 00000006 00000006 00000006 00000006 00000006
0000280 00000007 00000007 00000007 00000007 00000007 00000007 00000007 00000007 00000007 00000007
0000320 00000008 00000008 00000008 00000008 00000008 00000008 00000008 00000008 00000008 00000008
0000360 00000009 00000009 00000009 00000009 00000009 00000009 00000009 00000009 00000009 00000009
0000400
若要各個子進程的輸出不互相穿插,則需要把加鎖放在子進程輸出循環的外面。

vincentff7 发表于 2011-08-21 13:53

回复 7# MMMIX


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

hohoss 发表于 2011-08-21 15:24

回复 7# MMMIX


学习了,代码很严谨

hohoss 发表于 2011-08-21 15:28

本帖最后由 hohoss 于 2011-08-21 15:32 编辑

回复MMMIX


    查了下资料,记录锁是排队的FIFO队列。但为什么会出现楼主说的这种结果?
vincentff7 发表于 2011-08-21 13:53 http://bbs.chinaunix.net/images/common/back.gif


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


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

rd1chenqiang 发表于 2011-08-21 18:42

LZ 代码写得还是好乱。。 呵呵
页: [1] 2 3
查看完整版本: 问一个关于fork后的文件操作的IO问题