首先，进程拥有独立性，文件表也会拷贝父进程一份，但是文件是不会被拷贝的，也就是说子进程重定向是更改子进程的文件表，并不会影响父进程的。

并且，程序替换的时候也不会影响重定向打开的文件，因为程序替换替换的是程序的代码，而内存中的PCB，文件表，文件，都属于内核数据结构，就像进程的替换不会影响PCB内容的变化，也不会影响pid，ppid一样。

这样就完成了。

为什么linux下一切皆文件？

比如一些硬件，他们有自己的内核数据结构，他们每个都有自己的读写方法（键盘没有写功能，那就指向空），每种硬件读写方式都是不同的。

那么既然是不同的数据结构，怎么进行管理呢？

这时候就会定义一个结构体，里面记录硬件的数据，也能调用对应硬件的读写接口。

file是链接起来的，先描述，再组织。

所以操作系统看来，只需要调用file就可以了，所以说linux下皆文件。

那么，上面说到重定向的时候，为什么我们子进程退出时关闭了一个文件，按理来说父进程也会关闭文件，但是并没有，因为有一个叫做引用计数：

在结构体中有一个专门计数有多少个指针指向这个位置，如果这个数为0，文件就会关闭，如果不为0，即便是子进程关闭文件也就等于这个数减一而已。

因为用户要关闭文件和打开文件，只是我们去告诉操作系统我们要这么去做而已，剩下的就让操作系统实现具体内容。

缓冲区

首先来看一段代码:

打印正常

重定向正常

这时我加了一个fork创建子进程。

打印正常

这个内容是意料之外的。

为什么要有缓冲区

举个例子，我们古代如果普通人想给别人送东西，可能就需要自己一个人去送，费时费力，但是现代有快递站，所以就不用自己人力送了。

在内存中进程也是一样的，需要与外设有接触，但是外设的I/O特别慢，这时缓冲区就可以帮我们快速的与外设传递数据了。

缓冲区的本质就是一段内存！

缓冲区对应的刷新策略

缓冲区刷新也不是随意的刷新，而是根据外设去决定怎样去刷新的。

1.立即刷新，其实就和无缓冲一样。

2.行刷新，行缓存，这个就是相对应显示器，主要是针对人类做使用的，因为我们平时看文字都是一行一行从左到右去读，所以他就是一行一行刷新的，

3.缓冲区满，全缓冲，磁盘文件就是这样的，这个效率也是最快的，因为从进程中拷贝数据到传给外设，一次假设需要10s。

那么0.1s是在从进程拷贝数据到缓冲区，剩下时间就是缓冲区刷新到外设中的时间，也就是说如果进行多次的缓冲刷新，效率不如一次性缓冲刷新。

除了上面的策略，还有两种特殊的情况：

1.用户强制刷新

2.进程退出 ——— 一般都要进行缓冲区刷新

缓冲区的位置在哪里

我们在C语言的时候就一直再说缓冲区，那么它到底在什么位置呢？

刚才打印的代码说明，不在linux内核中，要不然wirte也会被打印两次。

其实我们所说的缓冲区是语言层次的缓冲区！因为在操作系统看来他也只是一块内存而已！

在stdout，stdin，stderr中，因为任何文件中都要去调用这三个，这三个的类型是FILE*，FILE也是一个结构体，里面不仅仅有fd，也有缓冲区！

这就是为什么刷新缓冲区的函数要传入文件指针，因为里面有缓冲区！

Linux中的FILE结构体：

在/usr/include/libio.h

struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
//缓冲区相关
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno; //封装的文件描述符
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};

所以说，我们再用文件指针的时候，输入的那些内容都会被封装到对应的文件指针那里，C语言会在合适的时候去刷新这个缓冲区。

那么上面的代码现在也可以进行解释为什么会出现奇怪的内容了。

首先要知道：没用重定向之前，stdout默认使用的是行刷新，在进程fork()之前，三条C函数已经将数据进行打印到显示器上了，这个时候我们的进程内部和FILE内部就没有数据了。

那么：使用重定向之后，写入文件的不是显示器，而是文件，所以就变成全缓存，之前的三天C函数虽然结尾有\n，但是没有写满stdout。

最重要的来了：执行fork的时候，原来的stdout是属于父进程的一部分，然后创建之后整个程序就退出了，之前说过刷新缓冲区的特殊条件，进程退出，并且，刷新缓冲区的时候等于将缓冲区的数据给对应的外设，所以就属于修改内容，那么子进程和父进程只读的时候是不会进行写时拷贝的，但是这里就要谁先退出谁就进行写时拷贝！所以C语言函数的接口就会打印两次！

那么wirte为什么只打印了一次呢？因为上面过程和wirte无关，wirte没有FILE，用的是fd，所以没有C语言提供的缓冲区！

操作系统的缓冲区

C语言层面有对应的缓冲区，系统也有，只不过系统层面的缓冲区是非常复杂的，是在file结构体里面的。

我们再写一个字符串首先拷贝到了语言层面的缓冲区，通过file，wirte写入到了内核缓冲区，至于什么时候从内核缓冲区写到硬盘对应的文件中，这个就需要看操作系统自己决定了（这个和用户毫无关系），有些时候缓存满了之后才会去写到对应的位置。

那么如果操作系统在自己的内核缓冲区又很多数据没来得及写入到指定位置就崩溃了呢？这就会导致数据丢失。

那么有没有什么解决的办法呢？

这个函数调用之后，强制让file对应的内核缓冲区持久到磁盘上！