I/O cổ điển — InputStream, Reader, buffered wrapper

Code sau đọc file 100MB:

try (FileInputStream fis = new FileInputStream("data.bin")) {
    int b;
    while ((b = fis.read()) != -1) {
        process(b);
    }
}

Thời gian: ~30 giây.

Thay 1 dòng:

try (InputStream in = new BufferedInputStream(new FileInputStream("data.bin"))) {
    int b;
    while ((b = in.read()) != -1) {
        process(b);
    }
}

Thời gian: ~0.3 giây. 100× chênh lệch với cùng API, cùng logic, chỉ thêm BufferedInputStream.

Lý do nằm ở level OS: read() một byte = 1 syscall xuống kernel, mỗi syscall tốn 1-5 microsecond. Đọc 100MB byte-by-byte = 100 triệu syscall. BufferedInputStream gom 8KB 1 lần syscall → giảm syscall 8000×.

Đây là bài học đầu tiên về I/O Java: API Java trông giống nhau nhưng khác nhau vô cùng về hiệu năng. Hiểu cơ chế OS + pattern decorator của java.io → biết ghép đúng wrapper để code không vừa sai vừa chậm.

Bài này đi qua: phân chia 2 nhánh API (byte stream vs char stream), pattern decorator nền tảng thiết kế java.io, vì sao buffer quan trọng ở cấp syscall, và charset — lý do new FileReader("x.txt") là bug latent trên Windows.

1. Analogy — Ống nước, xô, máy lọc

Tưởng tượng bạn cần chuyển nước từ giếng về nhà:

• FileInputStream: vặn vòi giếng, nước chảy từng giọt vào chén, bê về nhà. Đi 1 triệu chuyến cho 100 lít.
• BufferedInputStream: dùng xô 10 lít, múc đầy rồi bê về. 10k chuyến thay vì 1 triệu.
• InputStreamReader: máy lọc nước thành nước trái cây ở đầu vòi — chuyển từ "byte" sang "char" (decode theo charset).
• BufferedReader: xô chứa nước trái cây, còn có cốc lấy đúng 1 ly mỗi lần — tiện cho "đọc 1 dòng".

Mỗi class có 1 vai trò duy nhất. Ghép lại tạo pipeline đọc file. Đây là decorator pattern — trọng tâm thiết kế java.io.

Pipeline đầy đủ cho đọc text UTF-8 có readLine:

FileInputStream -> BufferedInputStream -> InputStreamReader -> BufferedReader
       ^                 ^                       ^                   ^
       source           buffer byte          byte -> char         buffer char + readLine

2. Hai nhánh API

Java chia I/O thành 2 nhánh riêng biệt:

Vì sao tách 2 nhánh?

Text cần encoding. File "hello.txt" trên disk là chuỗi byte. Cùng chuỗi byte có thể là:

• UTF-8: mỗi char 1-4 byte, tương thích ASCII.
• UTF-16: mỗi char 2-4 byte.
• Windows-1252, ISO-8859-1: mỗi char 1 byte.
• GBK, Shift-JIS: encoding CJK.

JVM nội tại dùng UTF-16 cho char. Đọc text từ file = decode byte → char theo charset cụ thể.

Byte stream không biết encoding — trả về raw byte. Char stream biết encoding — trả về char.

Nếu bạn đọc file PNG bằng Reader → JVM decode byte thành char → corrupt dữ liệu. Nếu đọc file text bằng InputStream → nhận byte thô → phải tự decode.

Rule: text → char stream + charset explicit. Binary → byte stream.

Hierarchy

flowchart TD
    A[InputStream abstract] --> B[FileInputStream]
    A --> C[ByteArrayInputStream]
    A --> D[BufferedInputStream]
    A --> E[DataInputStream]
    A --> F[ObjectInputStream]

    G[Reader abstract] --> H[FileReader]
    G --> I[InputStreamReader]
    G --> J[BufferedReader]

    K[Bridge byte to char] -.-> I

Class InputStreamReader là bridge giữa 2 nhánh: wrap InputStream, decode byte thành char với charset.

3. Đọc byte — FileInputStream + buffer

Pattern cơ bản

import java.io.*;

try (InputStream in = new BufferedInputStream(new FileInputStream("data.bin"))) {
    byte[] buf = new byte[8192];
    int n;
    while ((n = in.read(buf)) != -1) {
        process(buf, n);
    }
}

Breakdown:

• FileInputStream("data.bin"): mở file, return byte one-by-one nếu chỉ dùng read(), hoặc block nếu dùng read(byte[]).
• new BufferedInputStream(...): wrap — internal buffer 8KB, gom syscall.
• try-with-resources: bài 7.3 đã học — bắt buộc cho I/O tránh leak file descriptor.
• in.read(buf): đọc tối đa buf.length byte vào buf, trả số byte thực đọc được. Có thể < buf.length (file sắp hết) hoặc -1 (EOF).

Luôn check return value. Nhiều bug do xử lý byte "ma" từ phần cũ của buf:

// BAD
while (in.read(buf) != -1) {
    process(buf);   // Process ca byte cu con trong buf!
}

// GOOD
int n;
while ((n = in.read(buf)) != -1) {
    process(buf, n);   // Chi process n byte dau
}

Tại sao buf 8KB?

8KB là default size của BufferedInputStream và match với page size OS. Đọc 1 page OS ~ 1 syscall. Tăng buf lên 64KB giảm thêm syscall nhưng tốn memory — trade-off.

Rule: default 8KB đủ cho đa số case. File cực lớn (>1GB) có thể tăng lên 64KB hoặc 128KB. File nhỏ (< 1MB) tăng buf không lợi.

4. Đọc text — BufferedReader

3 tầng decorator

try (BufferedReader r = new BufferedReader(
        new InputStreamReader(
            new FileInputStream("log.txt"),
            StandardCharsets.UTF_8))) {
    String line;
    while ((line = r.readLine()) != null) {
        System.out.println(line);
    }
}

Đọc từ trong ra ngoài:

1. FileInputStream("log.txt"): byte từ disk.
2. InputStreamReader(fis, UTF_8): decode byte thành char. Bắt buộc pass charset.
3. BufferedReader(reader): buffer char + readLine() — tách line tự động theo \n / \r\n.

readLine() trả null khi EOF (không phải empty string — phải phân biệt "dòng rỗng" vs "hết file").

Vì sao 3 tầng?

Bạn có thể thắc mắc: "tại sao không có 1 class FileTextReader gom tất cả?"

Trả lời: flexibility. Mỗi tầng có thể thay:

// Doc tu network socket
BufferedReader r = new BufferedReader(
    new InputStreamReader(socket.getInputStream(), UTF_8));

// Doc tu ZIP entry
BufferedReader r = new BufferedReader(
    new InputStreamReader(zipStream, UTF_8));

// Doc tu decompress GZIP
BufferedReader r = new BufferedReader(
    new InputStreamReader(new GZIPInputStream(fis), UTF_8));

Cùng BufferedReader + readLine, source có thể là file, network, zip, gzip — chỉ thay component source. Decorator pattern cho phép compose linh hoạt.

FileReader shortcut — và bug

Java có FileReader — wrap sẵn FileInputStream + InputStreamReader:

try (BufferedReader r = new BufferedReader(new FileReader("log.txt"))) {
    ...
}

Vẻ ngắn gọn. Nhưng:

new FileReader("log.txt")

Constructor này dùng platform default charset. Trên Linux/macOS là UTF-8. Trên Windows thường là Windows-1252 (cp1252).

File UTF-8 có tiếng Việt, đọc trên Windows với default cp1252 → diacritics vỡ. Code pass CI (Linux) nhưng fail production (Windows).

Java 11+ thêm constructor nhận charset:

new FileReader("log.txt", StandardCharsets.UTF_8)

Với Java < 11, dùng InputStreamReader explicit:

new InputStreamReader(new FileInputStream("log.txt"), StandardCharsets.UTF_8)

Hoặc modern hơn — NIO.2 (bài 11.2):

Files.newBufferedReader(Path.of("log.txt"))   // Default UTF-8

5. Ghi file — BufferedWriter

try (BufferedWriter w = new BufferedWriter(
        new OutputStreamWriter(
            new FileOutputStream("out.txt"),
            StandardCharsets.UTF_8))) {
    w.write("Hello\n");
    w.write("World\n");
}   // Close auto flush

Pattern đối xứng đọc. Ghi buffer char → buffer byte → file.

Flush — quan trọng

Write vào BufferedWriter không ngay lập tức xuống disk. Nó vào buffer trong memory. Close writer tự flush buffer → ghi disk.

Nếu JVM crash trước close → mất data trong buffer.

Manual flush:

w.write("critical data");
w.flush();   // Ep xuong disk ngay

Tuy nhiên, flush() chỉ đảm bảo data xuống OS, chưa chắc xuống disk thật. OS có page cache — data có thể ở RAM OS chờ flush. Muốn thật sự xuống disk:

FileOutputStream fos = new FileOutputStream("data.log");
// ... write ...
fos.getFD().sync();   // fsync syscall - ghi thuc su xuong disk, cham

Hoặc dùng StandardOpenOption.SYNC với NIO.2 (bài 11.2).

Dùng khi nào:

• Flush thường: default cho mọi close() — đủ 99% case.
• flush() thủ công: transaction log, audit trail giữa chừng.
• fsync: DB transaction, điều kiện durability nghiêm ngặt (vd WAL log). Chậm ~5-50ms mỗi call — không dùng cho mỗi write.

6. Vì sao buffer quan trọng — chi tiết syscall

Đây là core concept, đáng ngâm kỹ.

Con số cụ thể

Đọc 100MB byte-by-byte

FileInputStream fis = new FileInputStream("100mb.dat");
while (fis.read() != -1) { ... }

fis.read() đọc 1 byte = 1 syscall.

100MB = 100 × 1024 × 1024 byte ≈ 100 triệu byte. 100 triệu syscall × 3μs = 300 giây = 5 phút.

Chưa kể disk I/O — mỗi syscall thường trả về 1 page nhưng bạn chỉ dùng 1 byte → phần còn lại đọc lại sau (trừ OS cache).

Đọc với buffer 8KB

BufferedInputStream in = new BufferedInputStream(new FileInputStream("100mb.dat"));
while (in.read() != -1) { ... }

Internal buffer 8KB. Lần đầu read(): gọi 1 syscall load 8KB vào buffer, trả byte đầu. 8191 byte sau đọc từ buffer, không syscall.

100MB / 8KB = 12800 syscall. 12800 × 3μs = 38ms.

Khác biệt 8000×. Free (không viết gì thêm, chỉ wrap).

Trade-off của buffer

Buffer lớn giảm syscall nhưng tốn memory. Buffer 1MB → 125 syscall cho 100MB file — chỉ thêm ~35% nhanh hơn 8KB. Không đáng.

Default 8KB là sweet spot — match page size OS, balance memory vs syscall.

7. Decorator pattern — tư duy thiết kế

Nhìn lại chain đọc gzip text:

InputStream fileStream = new FileInputStream("data.txt.gz");      // source
InputStream gzStream   = new GZIPInputStream(fileStream);          // decompress
InputStream bufStream  = new BufferedInputStream(gzStream);        // buffer byte
Reader reader          = new InputStreamReader(bufStream, UTF_8);  // byte -> char
BufferedReader br      = new BufferedReader(reader);               // buffer char + readLine

5 class wrap nhau, mỗi class 1 trách nhiệm. Thêm chức năng = thêm wrapper. Bỏ chức năng = bỏ wrapper.

Cần decrypt? Thêm CipherInputStream:

InputStream cipherStream = new CipherInputStream(gzStream, cipher);

Cần count byte read? Thêm custom wrapper count. Cần đọc chỉ N byte đầu? Wrap LimitedInputStream.

Pattern: Open/Closed principle (SOLID, module 6) — extend behavior bằng wrapper, không sửa class base.

Nhược: syntax dài, 5 class lồng nhau đọc khó. NIO.2 (java.nio.file) simplify nhiều — bài 11.2.

8. PrintWriter, PrintStream, System.out

PrintWriter wrap Writer, thêm println, printf, print:

try (PrintWriter pw = new PrintWriter(new BufferedWriter(
        new FileWriter("out.txt", StandardCharsets.UTF_8)))) {
    pw.println("Line 1");
    pw.printf("Price: %.2f%n", 12.5);
}

System.out là PrintStream — wrap file descriptor stdout. Auto-flush sau println — mỗi println flush ngay.

Hệ quả:

// Cham - flush sau moi println
for (int i = 0; i < 100_000; i++) {
    System.out.println(i);
}
// Mat vai giay

Wrap BufferedOutputStream để tắt auto-flush:

PrintStream buffered = new PrintStream(
    new BufferedOutputStream(System.out), false);   // autoFlush = false
System.setOut(buffered);

for (int i = 0; i < 100_000; i++) {
    System.out.println(i);
}
System.out.flush();   // Force flush khi can
// Nhanh 10x

Với script CLI output ngắn, auto-flush là đúng (thấy output ngay). Với batch job print nhiều, optimize cần thiết.

9. Pitfall tổng hợp

❌ Nhầm 1: Không dùng buffer.

try (FileInputStream fis = new FileInputStream("big.dat")) {
    int b;
    while ((b = fis.read()) != -1) process(b);   // 1 byte = 1 syscall
}

✅ Wrap BufferedInputStream:

try (InputStream in = new BufferedInputStream(new FileInputStream("big.dat"))) { ... }

❌ Nhầm 2: FileReader không specify charset.

new FileReader("utf8.txt");   // Platform default, bug Windows

✅ Java 11+: new FileReader(path, StandardCharsets.UTF_8) hoặc NIO.2 Files.newBufferedReader(path).

❌ Nhầm 3: Không close stream.

BufferedReader r = new BufferedReader(new FileReader("x"));
// Dung xong khong close -> leak file descriptor

✅ try-with-resources. Linux default limit 1024 FD, macOS thấp hơn — leak nhanh hết.

❌ Nhầm 4: Đọc bytes rồi new String(bytes) không charset.

byte[] data = Files.readAllBytes(path);
String s = new String(data);   // Platform default

✅ new String(data, StandardCharsets.UTF_8).

❌ Nhầm 5: Ghi binary qua Writer.

Writer w = new FileWriter("image.png");   // Writer cho char - corrupt binary
w.write(byteData);

✅ Dùng OutputStream cho binary:

OutputStream out = new FileOutputStream("image.png");
out.write(byteData);

❌ Nhầm 6: Process toàn bộ buf không check return value.

byte[] buf = new byte[8192];
while (in.read(buf) != -1) {
    process(buf);   // Process ca phan cu neu lan cuoi khong full
}

✅ Check:

int n;
while ((n = in.read(buf)) != -1) {
    process(buf, n);
}

10. 📚 Deep Dive Oracle

11. Tóm tắt

• 2 nhánh API: byte stream (InputStream/OutputStream) cho binary, char stream (Reader/Writer) cho text.
• BufferedXxx wrap cho hiệu năng — giảm syscall 1000-10000 lần. Default 8KB đủ.
• Decorator pattern: ghép nhiều wrapper cho chức năng (compress, encrypt, buffer, bridge byte/char).
• Luôn specify charset explicit — tránh FileReader không arg dùng platform default (bug latent Windows).
• try-with-resources bắt buộc cho mọi I/O — tránh leak file descriptor.
• BufferedReader.readLine() tiện đọc text line-by-line; trả null khi EOF.
• flush() đẩy buffer xuống OS; fsync / getFD().sync() đẩy thực sự xuống disk (chậm).
• Syscall ~3μs, method call ~1ns — chênh 3000×. Lý do buffer critical.
• System.out.println auto-flush — chậm trong loop lớn; wrap BufferedOutputStream nếu cần.
• Java 18+: UTF-8 default trên mọi platform (JEP 400).

12. Tự kiểm tra

try (var r = new BufferedReader(new FileReader("x.txt", StandardCharsets.UTF_8))) {
  String line = r.readLine();
  // ...
}

try (var r = Files.newBufferedReader(Path.of("x.txt"))) {
  // Default UTF-8, close auto qua try-with-resources
}

// Binh thuong
new BufferedInputStream(new FileInputStream(path))

// Decompress + encrypt + buffer
new BufferedInputStream(
  new CipherInputStream(
      new GZIPInputStream(
          new FileInputStream(path)),
      cipher))

Bài tiếp theo: NIO.2 — Path và Files, API hiện đại