Day 12: Standard Library I/O Mastery

Section 0: The "Why" & Core Vocabulary

ในโลก JVM / Spring Boot เมื่อเราต้องอ่านไฟล์ธุรกรรมของธนาคารขนาด 20GB หรืออ่าน Event log จากเครือข่าย เรามักเรียกใช้เมธอดอย่าง Files.readAllLines() หรือห่อหุ้ม Stream หลายชั้น:

// โค้ดสไตล์ Java/Kotlin ที่สร้างขยะมหาศาลบน Heap
val reader = BufferedReader(InputStreamReader(FileInputStream(file), StandardCharsets.UTF_8))
val lines = reader.readLines() // พังทันที OOM: โหลดข้อมูล 20GB ขึ้น RAM กลายเป็น String Objects พันล้านตัว!

Go ออกแบบระบบ I/O บนปรัชญา "Caller Allocates, Callee Populates": ผู้เรียก (Caller) จอง Slice ของ Byte เพียงชิ้นเดียว แล้วส่ง Pointer ของ Slice นั้นเข้าไปให้ Kernel หรือ Driver นำข้อมูลมาหยอดลงใน Buffer เดิมซ้ำๆ ทำให้การประมวลผลไฟล์ขนาด 100GB ใช้ Memory ในการทำงานคงที่เพียงแค่ไม่กี่ Kilobytes (O(1) Memory Footprint)!

Section 1: Go Syntax & Command Blueprint

ใน Standard Library แพ็กเกจ io ถูกออกแบบมาให้เรียบง่ายที่สุด แต่มีกฎทางไวยากรณ์และสัญญาระดับ Contract ที่เข้มงวดมาก:

1.1 The Golden Contract of io.Reader

// นิยามใน src/io/io.go
type Reader interface {
    Read(p []byte) (n int, err error)
}

1.2 การใช้งาน io.Reader แบบ Low-Level (Zero-Heap Loop)

package main

import (
    "errors"
    "fmt"
    "io"
    "os"
)

func StreamLedgerFile(filePath string) error {
    file, err := os.Open(filePath) // os.File implements io.Reader
    if err != nil {
        return fmt.Errorf("failed to open ledger: %w", err)
    }
    defer file.Close() // ปิด File Descriptor เสมอเมื่อจบฟังก์ชัน

    // จอง Buffer ขนาด 4KB บน Stack/Heap เพียงครั้งเดียวตลอดการอ่านไฟล์ 50GB!
    buf := make([]byte, 4096)

    for {
        n, err := file.Read(buf) // Callee เอาข้อมูลมาหยอดใส่ buf[0:n]
        if n > 0 {
            // ประมวลผลเฉพาะไบต์ที่อ่านได้จริง buf[:n] เท่านั้น
            chunk := buf[:n]
            processTransactionBytes(chunk)
        }

        if err != nil {
            if errors.Is(err, io.EOF) {
                // จบไฟล์อย่างสมบูรณ์แบบ
                break
            }
            // เกิด I/O Error จริง (เช่น Disk Fault, Bad Sector)
            return fmt.Errorf("read error: %w", err)
        }
    }
    return nil
}

func processTransactionBytes(b []byte) {
    // ประมวลผลไบต์ดิบ
}

1.3 การใช้งาน bufio.Scanner สำหรับประมวลผลทีละบรรทัด

หากต้องการอ่านไฟล์ธุรกรรมแบบ Line-by-Line (เช่น CSV หรือ JSON Lines) การใช้ bufio.Scanner คือทางเลือกที่เป็น Idiomatic Go ที่สุด:

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func ScanRaceBibs(r io.Reader) error {
    // ห่อหุ้ม Reader ด้วย bufio.Scanner
    scanner := bufio.NewScanner(r)

    // วนลูปอ่านทีละ Token (ค่าเริ่มต้นคือแบ่งด้วย Newline: '\n')
    for scanner.Scan() {
        // scanner.Bytes() คืน Slice ชี้ตรงไปยัง Internal Buffer (Zero-Copy!)
        // ระวัง: ค่าใน Bytes() จะเปลี่ยนไปในรอบ Scan() ถัดไป
        lineBytes := scanner.Bytes()
        
        // หรือดึงเป็น string (มีการ allocate string บน Heap)
        line := scanner.Text()
        fmt.Println("Scanned BIB record:", line)
    }

    // ตรวจสอบ Error หลังจบลูปเสมอ (Scanner จะกลืน io.EOF ไว้ แต่จะเก็บ I/O Error อื่นไว้ที่ .Err())
    if err := scanner.Err(); err != nil {
        return fmt.Errorf("scanner error: %w", err)
    }
    return nil
}

1.4 การเขียนข้อมูลด้วย io.Writer และ bufio.Writer

io.Writer มีเมธอดเดียวคือ Write(p []byte) (n int, err error) แต่หากเขียนไฟล์บ่อยๆ ทีละ 10–20 ไบต์ ระบบจะยิง System Call รัวๆ เราจึงต้องหุ้มด้วย bufio.NewWriter และ ต้องสั่ง Flush() เสมอ:

func WriteAuditLog(w io.Writer, records []string) error {
    // สร้าง Buffer ขนาด 4096 ไบต์ในหน่วยความจำ
    bufWriter := bufio.NewWriter(w)

    for _, rec := range records {
        _, err := bufWriter.WriteString(rec + "\n")
        if err != nil {
            return fmt.Errorf("failed to write record: %w", err)
        }
    }

    // กฎเหล็ก: ข้อมูลที่ค้างใน RAM Buffer จะยังไม่ลง Disk หรือ Socket จนกว่าจะ Flush!
    if err := bufWriter.Flush(); err != nil {
        return fmt.Errorf("failed to flush buffer: %w", err)
    }
    return nil
}

Section 2: Memory Architecture & Full Struct Definitions

เพื่อความเข้าใจระดับ Bare-Metal เราจะผ่า Struct ภายในของแพ็กเกจ bufio จาก Go Source Code (src/bufio/bufio.go) ว่าตัวแปรเก็บอะไรไว้ใน RAM และจัดเรียง Memory อย่างไร:

2.1 โครงสร้าง bufio.Reader (Total: 48 Bytes + Buffer Allocation)

// src/bufio/bufio.go
type Reader struct {
    buf          []byte        // 24 Bytes (Pointer 8B + Len 8B + Cap 8B)
    rd           io.Reader     // 16 Bytes (iface: tab 8B + data 8B)
    r, w         int           // 16 Bytes (r int 8B, w int 8B บน 64-bit)
    err          error         // 16 Bytes (iface: tab 8B + data 8B)
    lastRuneSize int           //  8 Bytes (ขนาด Rune ล่าสุดสำหรับ UnreadRune)
    lastByte     int           //  8 Bytes (ไบต์ล่าสุดสำหรับ UnreadByte)
}

2.2 Ring-Like Sliding Window Buffer ภายใน bufio.Reader

bufio.Reader บริหารพื้นที่ใน buf ด้วย Pointer Index 2 ตัวคือ r (Read Marker) และ w (Write Marker):

2.3 โครงสร้าง bufio.Scanner และ Tokenizer Memory

// src/bufio/scan.go
type Scanner struct {
    r            io.Reader // 16 Bytes: Target Reader
    split        SplitFunc //  8 Bytes: Function Pointer สำหรับแบ่ง Token
    maxTokenSize int       //  8 Bytes: เพดานขนาด Token (Default 64KB)
    token        []byte    // 24 Bytes: Slice ชี้ผลลัพธ์ Token ล่าสุด
    buf          []byte    // 24 Bytes: Buffer ภายในเริ่มต้นที่ 4KB ขยายได้ถึง maxTokenSize
    start        int       //  8 Bytes: Index เริ่มต้น Token
    end          int       //  8 Bytes: Index สิ้นสุด Token
    err          error     // 16 Bytes: Error สถานะ
    empties      int       //  8 Bytes: ตรวจจับ Empty token loop
    scanCalled   bool      //  1 Byte  : สถานะเรียก Scan
    done         bool      //  1 Byte  : จบ Stream หรือยัง
    // + 6 Bytes Padding ให้ครบ 8 Bytes Boundary
}

Section 3: Visual Workflow & Assembly/RAM Mechanics

ทำไมการใช้ bufio หรือ io.Reader ถึงทำงานได้เร็วกว่า และลดภาระของ CPU ได้มหาศาล? มาดูลำดับขั้นตอนการทำงานจริงระดับ Kernel และ OS System Calls

3.1 เปรียบเทียบ: Unbuffered Read vs Buffered Read

3.2 Zero-Copy Pipeline ด้วย io.Copy

เมื่อสั่ง io.Copy(dstWriter, srcReader) ตัว Go Runtime จะตรวจสอบแบบ Dynamic Interface Assertion ว่า srcReader หรือ dstWriter รองรับฟังก์ชันระดับ OS หรือไม่:

• หากอ่านจาก File ส่งไป Socket บน Linux: Go จะใช้ System Call sendfile(2) หรือ splice(2) ซึ่งส่ง Data ข้ามระหว่าง File Descriptor ในระดับ Kernel โดยตรง โดยไม่ก๊อปปี้ข้อมูลขึ้นมายัง User Space RAM เลยแม้แต่ไบต์เดียว! (True Zero-Copy)
• หากเป็น Reader/Writer ทั่วไป: Go จะสร้าง Buffer ชั่วคราวขนาด 32KB เพียงตัวเดียว และวน Loop อ่าน-เขียน จนกว่าจะพบ io.EOF

Section 4: Edge Cases, Hazards & Idiomatic Patterns

// วิธีแก้: หากต้องอ่านบรรทัดที่ยาวเกิน 64KB ให้ขยาย Buffer ล่วงหน้าด้วย Buffer()
scanner := bufio.NewScanner(reader)
// อนุญาตให้บรรทัดยาวได้สูงสุดถึง 10 MB
const maxCapacity = 10 * 1024 * 1024
buf := make([]byte, 64*1024)
scanner.Buffer(buf, maxCapacity)

// หายนะ: ทุกรอบจะได้ค่าขยะทับกัน
records := make([][]byte, 0)
for scanner.Scan() {
    records = append(records, scanner.Bytes()) // พัง! ทุก element ชี้ไปที่ buffer เดียวกัน
}

// วิธีแก้ที่ถูกต้อง: Clone ไบต์ออกมาเป็นของตัวเอง
for scanner.Scan() {
    b := scanner.Bytes()
    cloned := make([]byte, len(b))
    copy(cloned, b)
    records = append(records, cloned)
}

Idiomatic Go Patterns ในงาน I/O:

• Chain ด้วย Small Interfaces: หากต้องการอ่านข้อมูลที่มีการบีบอัด GZIP แล้วคำนวณ Hash SHA256 ใน Go คุณสามารถนำ io.TeeReader, gzip.NewReader, และ io.LimitReader มาประกบกันได้โดยไม่ต้องแก้โค้ดต้นทาง
• Prevent Resource Leaks with defer Close(): สำหรับประเภทข้อมูลที่ Implement io.Closer (เช่น *os.File หรือ net.Conn) ต้องสั่ง defer f.Close() ทันทีหลังตรวจสอบ err == nil สำเร็จ

Section 5: Knowledge Verification Quiz (16 Challenges)

ทดสอบความเข้าใจเชิงลึกระดับ Runtime & I/O Architecture ทุกข้อมีคะแนนสะสมและอธิบายเหตุผลอย่างละเอียด

Section 6: Hands-on Engineering Labs

เขียนโค้ด Go ตามหลัก Streaming Architecture ตรวจสอบความถูกต้องด้วย Verification Engine