标准I/O的缓冲

标准I/O实现了三种类型的用户缓冲，并为开发者提供了接口，可以控制缓冲区类型和大小。

• 无缓冲（Unbuffered）

　　　　不执行用户缓冲。数据直接提交给内核。因为这种无缓冲模式不支持用户缓冲（用户缓冲一般会带来很多好处），通常很少使用，只有一个例外：标准错误默认是采用无缓冲模式。

• 行缓冲（Line-buffered）

　　　　缓冲是以行为单位执行。每遇到换行符，缓冲区就会被提交给内核。行缓冲对把流输出到屏幕时很有用，因为输出到屏幕的消息也是通过换行符分隔的。因此，行缓冲是终端的默认缓冲模式，比如标准输出。

• 块缓冲（Block-buffered） 或 完全缓冲（full buffered）

　　　　缓冲以块为单位执行，每个块是固定的字节数。很适用与处理文件。默认情况下，和文件相关的所有流都是块缓冲模式。

大部分情况下，默认的缓冲模式对于特定场景是最高效的。但是，标准 I/O 还是提供了一个接口，可以修改使用的缓冲模式：

#include <stdio.h>

int setvbuf(FILE *stream, char *buf, int mode, size_t size);

mode 值必须是以下之一：

_IONBF ： 无缓冲

_IOLBF ： 行缓冲

_IOFBF ： 块缓冲

在 _IONBF 无缓冲模式下，会忽略参数 buf 和 size；对于其他模式，buf 可以指向一个 size 字节大小的缓冲空间，标准 I/O 会用它来执行对给定流的缓冲。如果 buf 为空，glibc 会自动分配指定 size 的缓冲区。

setvbuf() 函数必须在打开流后，并在执行任何操作之前被调用。

行缓冲：

#include <stdio.h>

int main(int argc, char* argv[])
{
        printf("hello world");
        while(1);
        return 0;
}

执行程序，看到没有输出“hello world”

如果在“hello world”后面加上“ ”，可以看到输出了“hello world”

说明标准输出的缺省模式是行缓冲

行缓冲大小：

#include <stdio.h>

int main(int argc, char* argv[])
{
        int i = 0;
        while(i < 1024)
        {
                printf("h");
                i++;
        }
        while(1);
        return 0;
}

如果把1024改成1025，就能看到输出，说明行缓冲的大小是1024字节

无缓冲：

#include <stdio.h>

int main(int argc, char* argv[])
{
        fprintf(stderr, "hello world");
        while(1);
        return 0;
}

可以看到“hello world”输出了，表明stderr是无缓冲的

#include <stdio.h>

int main(int argc, char* argv[])
{
        setvbuf(stdout, NULL, _IONBF, 0);
        fprintf(stdout, "hello world");
        while(1);
        return 0;
}

可以把 stdout 设置为无缓冲

#include <stdio.h>

char buf[2046];

int main(int argc, char* argv[])
{
        setvbuf(stdout, buf, _IOLBF, 2046);
        int i = 0;
        while(i < 2047)
        {
                printf("h");
                i++;
        }
        while(1);
        return 0;
}

可以改变缓冲区大小

行缓冲的输出条件：遇到换行符“ ”；缓冲区满

#include <stdio.h>

char buf[2046];

int main(int argc, char* argv[])
{
        setvbuf(stdout, buf, _IOLBF, 2046);
        int i = 0;
        while(i < 2046)
        {
                printf("h");
                if (i == 2000) printf("
");
                i++;
        }
        while(1);
        return 0;
}

在关闭流时，其使用的缓冲区必须存在。一个常见的错误就是把缓冲区定义成某一个作用域中的局部变量，在关闭流之前就退出这个作用域了。

#include <stdio.h>

int main(int argc, char* argv[])
{
        char buf[BUFSIZ];
        setvbuf(stdout, buf, _IOFBF, BUFSIZ);
        printf("Arrr!
");
        return 0;
        /* 'buf' exits scope and is freed, but stdout isn't closed until later */
}

这类错误可以通过两种方式解决：一是在离开作用域之前显示关闭流，二是把 buf 设置为全局变量

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#define BUF_SIZE 10
char buf[BUF_SIZE];

int myprintf(char* str)
{
        if (NULL == str) return;
        char *cur = str;
        int len = 0;
        int have_n = 0;
        while(*cur != '') {
                len++;
                cur++;
                if (*cur == '
') have_n = 1;
        }

        int buf_len = strlen(buf);
        int len_sum = buf_len + len;

        if (len_sum >= BUF_SIZE - 1 || have_n) {
                write(STDOUT_FILENO, buf, buf_len);
                memset(buf, 0, BUF_SIZE);
                write(STDOUT_FILENO, str, len);
        }
        else {
                strncpy(buf, str, len);
                buf[BUF_SIZE] = '';
        }
        return 0;
}

int main(int argc, char* argv[])
{
        myprintf("1234
5678");
        //myprintf("9");
        return 0;
}

标准 I/O 函数在本质上是线程安全的。在每个函数的内部实现中，都关联了一把锁、一个锁计数器，以及持有该锁并打开一个流的线程。每个线程在执行任何 I/O 请求之前，必须首先获得锁而且持有该锁。两个或多个运行在同一流上的线程不会交叉执行标准 I/O 操作，因此，在单个函数调用中，标准 I/O 操作是原子操作。