GroupBlog

1.问题

多个进程对同一个文件进行访问会使得写入的数据出现错乱吗,write与fwrite之间到底有什么区别呢,哪种情况会丢掉数据呢.

2.结论

多个进程写同一个文件不会出现数据交叉的情况
在多进程使用write时不会丢掉数据, fwrite会丢掉数据
fwrite速度优于write

3.实验

write版本

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<time.h>

int main(){
    pid_t pid;
    pid = fork();
    char* pathname = "test.txt"; 
    char* ChildProcess = "aaaaa\n";
    char* FatherProcess = "bbbbb\n";

    switch (pid)
    {
        case 0:
            {
                printf("in the child\n");
                int fd = open(pathname, O_RDWR | O_APPEND);
                for(int i=0;i<100000;++i){
                    write(fd, ChildProcess,6);
                }
                close(fd);
                break;
            }
        case -1:
            perror("error message\n");
            break;
        default:
            {
                printf("in the father\n");
                int fd = open(pathname, O_RDWR | O_APPEND);
                for(int i=0;i<100000;++i){
                    write(fd, FatherProcess, 6);
                }
                close(fd);
                break;
            }
    }
    return 0;
}

非常简单的一个测试代码父子进程同时向test.txt文件写内容我们可以看到结果是这样的,
在这里插入图片描述

在这里插入图片描述
我们可以看到父子进程交替打印且200000行没有丢失数据
如果改为fwrite呢我们来看看下面的测试代码

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>

int main(){
    pid_t pid;
    pid = fork();
    char* pathname = "test.txt"; 
    char ChildProcess[7] = "aaaaa\n";
    char FatherProcess[7] = "bbbbb\n";

    switch (pid)
    {
        case 0:
            {
                printf("in the child\n");
                FILE* fl = fopen(pathname, "rt+");
                for(int i=0;i<100000;++i){
                    fwrite(ChildProcess, 6,1,fl);
                }
                fclose(fl);
                break;
            }
        case -1:
            perror("error message\n");
            break;
        default:
            {
                printf("in the father\n");
                FILE* fl = fopen(pathname, "rt+");
                for(int i=0;i<100000;++i){
                    fwrite(FatherProcess, 6,1,fl);
                }
                fclose(fl);
                break;
            }
    }
    return 0;
}

我们来看看打印结果

在这里插入图片描述

我们可以发现出现了数据交叉且不止一处出现了数据交叉而且数据只有一半,有十万行数据丢失了,

对比一下时间也非常的令人震惊

write:
在这里插入图片描述

fwrite:
在这里插入图片描述
我们可以看到对于相同的十万组读写时间相差近150倍,这是一个很可怕的数据了,这是为什么呢,其实时间相差这个问题很好解释,一个write系统调用因为牵扯到磁盘的读写非常的耗时,相比与L1,L2级别的高速缓存,读取磁盘的周期数(csapp p345)为前者的几千倍!一次write意味着我们需要访问一次磁盘,且还有一次系统调用,经历内核态到用户态的转换和上下文切换,十万次的写入相当于十万次的系统调用,以及十万次的写入磁盘,而fwrite相当于write的一个封装,维护一个用户态buf,可以在内存中存储要写入磁盘的数据, 到了一定的量一次写入,一次减少读入磁盘的次数,所以时间差异如此的大.

接下来的问题是为什么多进程write写入不会出现数据交叉,而fwite会出现

关键在于O_APPEND这个参数看一段源码

ssize_t generic_file_aio_write(struct kiocb *iocb, const char __user *buf,
			       size_t count, loff_t pos)
{
	struct file *file = iocb->ki_filp;
	struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;
	ssize_t ret;
	struct iovec local_iov = { .iov_base = (void __user *)buf,
					.iov_len = count };

	BUG_ON(iocb->ki_pos != pos);

	down(&inode->i_sem);
	ret = __generic_file_aio_write_nolock(iocb, &local_iov, 1,
						&iocb->ki_pos);
	up(&inode->i_sem);

	if (ret > 0 && ((file->f_flags & O_SYNC) || IS_SYNC(inode))) {
		ssize_t err;

		err = sync_page_range(inode, mapping, pos, ret);
		if (err < 0)
			ret = err;
	}
	return ret;
}

inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk)
{
	struct inode *inode = file->f_mapping->host;
	unsigned long limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;

        if (unlikely(*pos < 0))
                return -EINVAL;

        if (unlikely(file->f_error)) {
                int err = file->f_error;
                file->f_error = 0;
                return err;
        }

	if (!isblk) {
		/* FIXME: this is for backwards compatibility with 2.4 */
		if (file->f_flags & O_APPEND)
                        *pos = i_size_read(inode);

		if (limit != RLIM_INFINITY) {
			if (*pos >= limit) {
				send_sig(SIGXFSZ, current, 0);
				return -EFBIG;
			}
			if (*count > limit - (typeof(limit))*pos) {
				*count = limit - (typeof(limit))*pos;
			}
		}
		.......................
	}

generic_write_checks由__generic_file_aio_write_nolock调用

我们可以看到当检测到mode为有O_APPEND时就是把偏移量调整到当前数据的长度而这个操作是加锁的(信号量) 意味着写入操作是原子性的,所以直接write数据不会丢失,还是20万行,但是fwrite操作只输出十万行,这个现在确实没办法解释,了解的朋友希望能在评论区留下宝贵的指导

send与recv也是原子操作意味着我们对套接字的操作也是多进程或多线程操作的
https://stackoverflow.com/questions/1981372/are-parallel-calls-to-send-recv-on-the-same-socket-valid

本人水平有限,错误之处请指正

参考

https://blog.csdn.net/yangbodong22011/article/details/63064166
https://blog.csdn.net/zhangyifei216/article/details/76653746