Phase 2: Channels Deep-Dive & hchan Architecture

package main

import (
    "fmt"
    "time"
)

type Transaction struct {
    TxID   string
    Amount int64 // หน่วยสตางค์ (Cents)
}

// 1. Send-Only Channel (chan<-): ผู้ส่งทำได้แค่ยัดข้อมูลเข้าและปิด Channel
func ingestTransactions(out chan<- Transaction) {
    txs := []Transaction{
        {"TX-1001", 50000},
        {"TX-1002", 125000},
        {"TX-1003", 9900},
    }

    for _, tx := range txs {
        out <- tx // ส่งข้อมูลเข้า Channel (หาก Buffer เต็ม จะบล็อกตรงนี้)
        fmt.Printf("[Ingest] Pushed %s\n", tx.TxID)
    }

    // 2. กฎเหล็ก: ผู้ส่ง (Producer) เป็นผู้ปิด Channel เสมอเมื่อส่งข้อมูลครบแล้ว!
    close(out)
}

// 3. Receive-Only Channel (<-chan): ผู้ประมวลผลทำได้แค่อ่านข้อมูลออก
func processSettlement(in <-chan Transaction, done chan<- bool) {
    // 4. for range บน Channel จะวนลูปอ่านเรื่อยๆ จนกว่า Channel จะถูก close()
    for tx := range in {
        fmt.Printf("[Settlement] Cleared %s for %d cents\n", tx.TxID, tx.Amount)
        time.Sleep(5 * time.Millisecond)
    }

    // แจ้ง Main Goroutine ว่าทำงานเสร็จสิ้นแล้ว
    done <- true
}

func main() {
    // สร้าง Buffered Channel ขนาด 10 รายการ ป้องกัน Ingestion Block ทันที
    txStream := make(chan Transaction, 10)
    done := make(chan bool)

    go ingestTransactions(txStream)
    go processSettlement(txStream, done)

    // รอรับสัญญาณเสร็จสิ้น (Unbuffered Channel Rendezvous)
    <-done
    fmt.Println("[Ledger] Daily settlement pipeline finished cleanly.")
}

type hchan struct {
    qcount   uint           // 8 Bytes: จำนวนสมาชิกที่ค้างอยู่ใน buffer ปัจจุบัน
    dataqsiz uint           // 8 Bytes: ขนาดความจุ buffer สูงสุด (circular queue capacity)
    buf      unsafe.Pointer // 8 Bytes: Pointer ชี้ไปยัง Circular Array ใน RAM
    elemsize uint16         // 2 Bytes: ขนาดของแต่ละ element (ไบต์)
    closed   uint32         // 4 Bytes: สถานะปิด channel (0 = Open, 1 = Closed)
    elemtype *_type         // 8 Bytes: Type metadata ของข้อมูลที่ส่งผ่าน
    sendx    uint           // 8 Bytes: Buffer index สำหรับการส่ง (Send Index)
    recvx    uint           // 8 Bytes: Buffer index สำหรับการรับ (Receive Index)
    recvq    waitq          // 16 Bytes: คิวของ Goroutines ที่รอรับข้อมูล (Linked list ของ sudog)
    sendq    waitq          // 16 Bytes: คิวของ Goroutines ที่รอส่งข้อมูล (Linked list ของ sudog)
    lock     mutex          // 8 Bytes: Low-level spinlock ปกป้องฟิลด์ทั้งหมดใน hchan
}

type waitq struct {
    first *sudog // 8 Bytes: ชี้ไปหา Goroutine แรกที่หลับรออยู่
    last  *sudog // 8 Bytes: ชี้ไปหา Goroutine ท้ายสุดในคิว
}

type sudog struct {
    g           *g             // Goroutine ตัวจริงที่กำลังถูก Park
    elem        unsafe.Pointer // Pointer ชี้ไปยังตำแหน่งตัวแปรใน Stack เพื่อทำ Direct Transfer
    acquiretime int64
    releasetime int64
    ticket      uint32
    isSelect    bool
    next        *sudog         // Intrusive linked list
    prev        *sudog
    ...
}