Java for Beginner

Раздел 11. Работа с файлами, I/O и сетью (NIO.2)

Глава 1. Классический Java I/O (java.io)

BufferedInputStream – буферизованное чтение. Путь данных через память JVM

BufferedInputStream — декоратор над InputStream, добавляющий внутреннюю буферизацию к любому underlying потоку. Он не является самостоятельным источником данных, а служит промежуточным слоем, который накапливает данные в памяти и выдает их порциями при запросе. Это устраняет главный недостаток побайтового чтения: накладные расходы системных вызовов.

Ключевое архитектурное решение — разделение ответственности. FileInputStream отвечает за взаимодействие с ОС и файловой системой. BufferedInputStream отвечает за оптимизацию паттерна доступа: замену множества мелких запросов на несколько крупных. Это классический применение паттерна декоратора в Java I/O.

Внутреннее устройство

// Упрощенная структура из OpenJDK
public class BufferedInputStream extends FilterInputStream {
    // Внутренний буфер в heap JVM
    protected volatile byte[] buf;
    
    // Количество байт, фактически доступных в буфере
    protected int count;
    
    // Текущая позиция чтения в буфере
    protected int pos;
    
    // Позиция маркера для mark/reset, -1 если не установлен
    protected int markpos = -1;
    
    // Максимальное количество байт, читаемых после mark
    protected int marklimit;
    
    // Конструкторы
    public BufferedInputStream(InputStream in) {
        this(in, 8192); // Размер по умолчанию
    }
    
    public BufferedInputStream(InputStream in, int size) {
        super(in);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size]; // Выделение в heap
    }
}

Поля buf, count, pos образуют кольцевой буфер (ring buffer), хотя в стандартной реализации используется линейный массив с сдвигом при исчерпании. При вызове read() BufferedInputStream сначала проверяет pos < count. Если условие истинно — байт возвращается из buf[pos++] без системного вызова. Если ложно — выполняется fill(), который читает новый блок данных из underlying потока.

Механика fill() и путь данных

Метод fill() — сердце буферизации. Он выполняется, когда внутренний буфер исчерпан:

// Упрощенная логика fill()
private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    
    if (markpos < 0) {
        // Маркер не установлен — читаем с начала буфера
        pos = 0;
    } else if (pos >= buffer.length) {
        // Позиция достигла конца буфера
        if (markpos > 0) {
            // Сдвигаем данные от markpos к началу
            int sz = pos - markpos;
            System.arraycopy(buffer, markpos, buffer, 0, sz);
            pos = sz;
            markpos = 0;
        } else if (buffer.length >= marklimit) {
            // Буфер превысил лимит маркера — сбрасываем
            markpos = -1;
            pos = 0;
        } else {
            // Расширяем буфер
            int nsz = pos * 2;
            if (nsz > marklimit) nsz = marklimit;
            byte[] nbuf = new byte[nsz];
            System.arraycopy(buffer, 0, nbuf, 0, pos);
            buf = nbuf;
            buffer = nbuf;
            markpos = 0;
        }
    }
    
    count = pos;
    // Системный вызов: чтение из underlying потока
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0) count = n + pos;
}

Путь данных при fill():
Проверка состояния буфера. Определение, можно ли читать с начала или требуется сдвиг/расширение.
Системный вызов read(). getInIfOpen().read(buffer, pos, len) — один вызов для чтения до buffer.length - pos байт.
Копирование в heap. Данные из нативного буфера через JNI попадают в buf в heap.
Обновление счетчиков. count устанавливается в количество фактически прочитанных байт.

Путь данных в памяти: детальный разбор

Сценарий: первое чтение после создания

try (BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("data.bin"), 8192)) {
    
    int firstByte = bis.read(); // Инициирует fill()
}

Путь данных для первого read():

[Java: bis.read()]
  -> [BufferedInputStream: pos=0, count=0, буфер пуст]
    -> [fill()]
      -> [FileInputStream.read(buf, 0, 8192)]
        -> [JNI: нативный readBytes]
          -> [Ядро ОС: syscall read(fd, native_buf, 8192)]
            -> [Page Cache: поиск/загрузка страниц]
            -> [Копирование: 8192 байт из page cache в native_buf]
          -> [Возврат в userspace]
        -> [JNI: копирование 8192 байт в buf[8192] в heap]
      -> [BufferedInputStream: count=8192, pos=0]
    -> [Возврат buf[0] как int]

Массив buf[8192] создан при конструировании BufferedInputStream и размещен в heap. Для размера 8192 байт это обычный объект, не humongous. Он размещается в Eden space young generation.

Сценарий: последующие чтения из буфера

int secondByte = bis.read(); // pos=1, count=8192, системный вызов отсутствует
int thirdByte = bis.read();  // pos=2, count=8192, системный вызов отсутствует

[Java: bis.read()]
  -> [BufferedInputStream: pos < count? 1 < 8192 — да]
    -> [Возврат buf[1] как int, pos++]

Никаких системных вызовов, никакого JNI, никакого обращения к ядру. Данные извлекаются из массива в heap напрямую JVM-байткодом. Это на порядки быстрее, чем побайтовое чтение через FileInputStream.

Сценарий: буфер исчерпан

// После 8192 вызовов read()
int byte8193 = bis.read(); // pos=8192, count=8192, буфер пуст

[Java: bis.read()]
  -> [BufferedInputStream: pos < count? 8192 < 8192 — нет]
    -> [fill()]
      -> [System.arraycopy при необходимости]
      -> [FileInputStream.read(buf, 0, 8192)]
        -> [Новый системный вызов]
      -> [count=новое_значение, pos=0]
    -> [Возврат buf[0]]

#Java #для_новичков #beginner #IO #NIO #BufferedInputStream

👍4

73 views08:59