BufReader в Rust: ускоряем ввод-вывод

В этой статье разберём зачем нужен BufReader, как он работает и какие есть способы читать данные из файлов. Мы сравним разные подходы и посмотрим сколько они занимают времени.

🎙️ К статье прилагается подкаст-версия - лёгкий и образный рассказ с аналогиями. Включайте, если хотите услышать объяснение на слух.
Подкаст Rust в деталях. Выпуск 1

Трейты и чтение данных
#

В Rust трейты описывают общее поведение. Если тип реализует трейт - он “умеет” делать определённые действия.

Например, трейт Read говорит: “этот объект можно читать”. Под него попадают файлы (File), сетевые соединения (TcpStream), стандартный ввод (stdin).

Главный метод:

fn read(&mut self, buf: &mut [u8]) -> Result<usize>;

Он записывает доступные байты в буфер и возвращает число реально прочитанных. Чтобы загрузить все данные - .read() вызывают многократно.

Системные вызовы и их цена
#

Когда мы читаем файл или сокет через Read, каждый вызов .read() почти всегда приводит к системному вызову read(2) (на Linux/Unix) или его аналогу в других ОС.

⚙️ Разберём по шагам что же происходит когда в коде вызвается этот метод:

Программа вызывает метод .read().
Процессор переключается из пользовательского режима (user mode) в режим ядра (kernel mode).
ОС выполняет реальную операцию чтения: обращается к диску, сети или памяти.
Управление возвращается в пользовательское приложение.

Каждый такой переход - это сотни инструкций процессора. Поэтому чтение по 1 байту с диска будет катастрофически медленным.

BufReader
#

Чтобы уменьшить число системных вызовов существует BufReader.

Он один раз считывает крупный блок (по умолчанию 8 КБ) во внутренний буфер, а дальше выдаёт данные уже из памяти. Так вместо тысячи вызовов вы получаете десятки.

BufReader: чтение всего файла

Шаг 1/2

 1// ?hidden:start
 2use std::fs::{File, OpenOptions};
 3use std::io::{self, BufReader, Read, Write};
 4use std::path::Path;
 5
 6fn ensure_file() -> io::Result<()> {
 7    if !Path::new("hello.txt").exists() {
 8        let mut f = OpenOptions::new().create(true).write(true).open("hello.txt")?;
 9        writeln!(f, "Знакомство с BufReader!")?;
10    }
11    Ok(())
12}
13// ?hidden:end
14fn main() -> io::Result<()> {
15    // Проверяем, что файл существует (создаём при необходимости)
16    ensure_file()?;
17    
18    // Открываем файл
19    let file = File::open("hello.txt")?;
20    
21    // Оборачиваем его в BufReader
22    let mut reader = BufReader::new(file);
23
24    // Читаем содержимое в строку
25    let mut contents = String::new();
26    reader.read_to_string(&mut contents)?;
27
28    println!("Содержимое файла: {}", contents);
29
30    Ok(())
31}
32

Разберем подробнее:

Функция ensure_file проверяет наличие файла hello.txt. Если его нет — создаём и записываем туда строку “Знакомство с BufReader!”.
В main открываем файл и оборачиваем его в BufReader. Буферизованное чтение делает работу эффективной.
С помощью read_to_string считываем всё содержимое в строку.
Результат печатаем в консоль.

Это самый простой пример: мы просто читаем файл целиком. Но ключевая идея уже видна - BufReader используется как оболочка вокруг файла, которая делает операции ввода-вывода более эффективными.

Результат выполнения:

 1use std::fs::{File, OpenOptions};
 2use std::io::{self, BufReader, BufRead, Write};
 3use std::path::Path;
 4
 5
 6fn ensure_file() -> io::Result<()> {
 7    if !Path::new("app.log").exists() {
 8        let mut f = OpenOptions::new().create(true).write(true).open("app.log")?;
 9        writeln!(f, "[2025-08-27 10:00:01] INFO  — Приложение запущено")?;
10        writeln!(f, "[2025-08-27 10:00:03] WARN  — Соединение нестабильно")?;
11        writeln!(f, "[2025-08-27 10:00:05] ERROR — Ошибка чтения конфигурации")?;
12        writeln!(f, "[2025-08-27 10:00:07] INFO  — Перезапуск сервиса")?;
13    }
14    Ok(())
15}
16
17
18fn main() -> io::Result<()> {
19    ensure_file()?;
20
21    let file = File::open("app.log")?;
22    let reader = BufReader::new(file);
23
24    let mut line_count = 0;
25    let mut error_count = 0;
26
27    for line in reader.lines() {
28        let line = line?;
29        line_count += 1;
30        if line.contains("ERROR") {
31            error_count += 1;
32        }
33        println!(">> {}", line);
34    }
35
36    println!("\nВ логе {} строки. Из них {} с ошибками.", line_count, error_count);
37
38    Ok(())
39}
40

Разберем подробнее что же тут происходит. Мы читаем лог-файл с помощью BufReader:

Функция ensure_file имитирует создание файла с логом приложения. Если файла app.log нет — создаём его и записываем несколько строк с метками времени, уровнями логов (INFO, WARN, ERROR) и сообщениями.
В main открываем файл и оборачиваем его в BufReader чтобы читать эффективно.
С помощью reader.lines() проходим построчно в цикле:
- считаем общее количество строк
- ищем вхождения слова "ERROR" и увеличиваем отдельный счётчик ошибок
- печатаем строку с префиксом >>
После цикла выводим статистику: сколько строк всего и сколько среди них сообщений об ошибках.

Такой приём реально полезен: BufReader позволяет работать даже с огромными логами построчно, без необходимости загружать их целиком в память.

Результат выполнения:

BufRead против Read
#

BufReader реализует трейт BufRead, который расширяет возможности Read.

Зачем нужен отдельный трейт? Потому что некоторые операции становятся эффективными только при наличии внутреннего буфера.

Например, метод .lines() возвращает итератор по строкам:

BufReader: построчное чтение

 1use std::fs::{File, OpenOptions};
 2use std::io::{self, BufReader, BufRead, Write};
 3
 4// Создадим файл
 5fn ensure_file() -> io::Result<()> {
 6    if !std::path::Path::new("data.txt").exists() {
 7        let mut f = OpenOptions::new().create(true).write(true).open("data.txt")?;
 8        writeln!(f, "Первая строка")?;
 9        writeln!(f, "Вторая строка")?;
10        writeln!(f, "Третья строка")?;
11    }
12    Ok(())
13}
14
15fn main() -> io::Result<()> {
16    ensure_file()?;
17
18    let file = File::open("data.txt")?;
19    let reader = BufReader::new(file);
20
21    for line in reader.lines() {
22        println!("{}", line?);
23    }
24
25    Ok(())
26}
27

Разберем подробнее:

BufReader читает файл большими блоками и хранит их в своём буфере.
Трейт BufRead добавляет методы, которые работают не с файловым дескриптором напрямую, а с этим буфером в памяти.
Метод .lines() ищет символ перевода строки \n в буфере и возвращает готовые строки.

Если бы у нас был только Read, то для поиска конца строки пришлось бы каждый раз вызывать .read() → это означало бы больше системных вызовов и ненужных копирований.

Результат выполнения:

Другие полезные методы BufRead:
#

.read_line(&mut String) — читает одну строку целиком в переданную строку.
.split(u8) — возвращает итератор, разделяющий поток по заданному байту.
.fill_buf() — даёт прямой доступ к текущему содержимому буфера (без копирования).
.consume(n) — указывает сколько байт “съесть” из буфера после обработки.

Четыре способа читать файл построчно
#

Чтобы увидеть разницу, сравним четыре подхода.

Примеры для 4 подходов

Шаг 1/4

 1// ?hidden:start
 2use std::fs::{self, OpenOptions};
 3use std::io::{self, Write, Read};
 4use std::path::Path;
 5use std::fs::File;
 6
 7
 8/// Создаём файл big.txt, если его ещё нет.
 9/// 100_0 строк с текстом и номерами.
10fn ensure_file() -> io::Result<()> {
11    if Path::new("big.txt").exists() {
12        return Ok(());
13    }
14    println!("Создается файл big.txt...");
15    let mut f = OpenOptions::new().create(true).write(true).open("big.txt")?;
16    for i in 0..100_0 {
17        writeln!(f, "Строка номер {i:06} — пример содержимого файла для BufReader")?;
18    }
19    println!("Файл создан!");
20    Ok(())
21}
22// ?hidden:end
23fn main() -> io::Result<()> {
24    ensure_file()?; // создаём файл
25
26    let start = std::time::Instant::now();
27    let mut file = File::open("big.txt")?;
28    let mut buffer = [0; 1];
29    let mut line = String::new();
30
31    while file.read(&mut buffer)? > 0 {
32        let ch = buffer[0] as char;
33        if ch == '\n' {
34            line.clear();
35        } else {
36            line.push(ch);
37        }
38    }
39    let end = std::time::Instant::now();
40    println!("Время выполнения: {:?}", end - start);
41
42    Ok(())
43}
44

Небуферизованное чтение по одному символу

❌ Очень медленно ~123 миллисекунды

Здесь каждая операция read идёт напрямую к ОС. Удобно для понимания, но не для реальной работы.

Результат выполнения:

 1// ?hidden:start
 2use std::fs::{self, OpenOptions};
 3use std::io::{self, Write, BufRead, BufReader};
 4use std::path::Path;
 5use std::fs::File;
 6
 7/// Создаём файл big.txt, если его ещё нет.
 8/// 100_0 строк с текстом и номерами.
 9fn ensure_file() -> io::Result<()> {
10    if Path::new("big.txt").exists() {
11        return Ok(());
12    }
13    println!("Создается файл big.txt...");
14    let mut f = OpenOptions::new().create(true).write(true).open("big.txt")?;
15    for i in 0..100_0 {
16        writeln!(f, "Строка номер {i:06}")?;
17    }
18    println!("Файл создан!");
19    Ok(())
20}
21// ?hidden:end
22fn main() -> io::Result<()> {
23    ensure_file()?; // создаём файл
24    let start = std::time::Instant::now();
25    let mut lines_count = 0;
26
27    let file = File::open("big.txt")?;
28    let reader = BufReader::new(file);
29
30    for line in reader.lines() {
31        lines_count += 1;
32    }
33
34    let end = std::time::Instant::now();
35    println!("Время выполнения: {:?}", end - start);
36
37    Ok(())
38}
39

BufReader + .lines()

⚡ Гораздо быстрее ~500µs

Это стандартный способ, удобный и быстрый.

Результат выполнения:

 1// ?hidden:start
 2use std::fs::{self, OpenOptions};
 3use std::io::{self, Write, BufRead, BufReader};
 4use std::path::Path;
 5use std::fs::File;
 6
 7
 8
 9/// Создаём файл big.txt, если его ещё нет.
10/// 100_0 строк с текстом и номерами.
11fn ensure_file() -> io::Result<()> {
12    if Path::new("big.txt").exists() {
13        return Ok(());
14    }
15    println!("Создается файл big.txt...");
16    let mut f = OpenOptions::new().create(true).write(true).open("big.txt")?;
17    for i in 0..100_0 {
18        writeln!(f, "Строка номер {i:06}")?;
19    }
20    println!("Файл создан!");
21    Ok(())
22}
23// ?hidden:end
24fn main() -> io::Result<()> {
25    ensure_file()?; // создаём файл
26
27    let start = std::time::Instant::now();
28    let mut lines_count = 0;
29    let file = File::open("big.txt")?;
30    let mut reader = BufReader::new(file);
31    let mut line = String::new();
32
33    while reader.read_line(&mut line)? > 0 {
34        lines_count += 1;
35        line.clear(); // строка очищается, но не выделяется заново
36    }
37
38    let end = std::time::Instant::now();
39    println!("Время выполнения: {:?}", end - start);
40
41    Ok(())
42}
43

BufReader + переиспользование строки

⚡ Ещё быстрее ~360µs read_line записывает прямо в существующую строку. Нет лишних аллокаций памяти, работает эффективнее.

Результат выполнения:

 1// ?hidden:start
 2use std::fs::{self, OpenOptions};
 3use std::io::{self, Write, Read};
 4use std::path::Path;
 5use std::fs::File;
 6
 7/// Создаём файл big.txt, если его ещё нет.
 8/// 100_0 строк с текстом и номерами.
 9fn ensure_file() -> io::Result<()> {
10    if Path::new("big.txt").exists() {
11        return Ok(());
12    }
13    println!("Создается файл big.txt...");
14    let mut f = OpenOptions::new().create(true).write(true).open("big.txt")?;
15    for i in 0..100_0 {
16        writeln!(f, "Строка номер {i:06}")?;
17    }
18    println!("Файл создан!");
19    Ok(())
20}
21// ?hidden:end
22fn main() -> io::Result<()> {
23
24    ensure_file()?; // создаём файл
25    let start = std::time::Instant::now();
26
27    let mut lines_count = 0;
28    let mut file = File::open("big.txt")?;
29    let mut contents = String::new();
30    file.read_to_string(&mut contents)?;
31
32    for line in contents.lines() {
33        lines_count += 1;
34    }
35
36    let end = std::time::Instant::now();
37    println!("Время выполнения: {:?}", end - start);
38
39    Ok(())
40}
41

4. Еще один вариант

⚡ ~270µs Всё содержимое читается за раз, а потом разбивается на строки.

Время выполнения у вас может отличаться от представленного здесь.

Минус: выделяется объём памяти равный размеру файла.

Результат выполнения:

Когда BufReader не нужен
#

Хотя BufReader полезен в большинстве сценариев, есть ситуации, когда он не только не ускорит программу, но и будет лишним.

1. Данные уже в памяти
#

Если у вас есть Vec<u8>, String или срез &[u8], никакого дополнительного системного вызова не происходит. Данные уже находятся в оперативной памяти, а значит никакой выгоды от дополнительного буфера не будет.

2. Чтение крупными блоками
#

Если вы сразу читаете данные большими кусками (десятки или сотни килобайт), то накладные расходы на системные вызовы становятся несущественными.

3. Ограниченная память
#

Если у вас тысячи одновременных соединений (например, работаете с сервером), каждый BufReader создаёт внутренний буфер (по умолчанию 8 КБ). При тысячах соединений это может означать десятки мегабайт памяти, которые не всегда оправданы.

В асинхронном коде часто используют другие подходы: читают ровно столько - сколько пришло в сокете и сами управляют буферами чтобы экономить память.