Memory and Performance

Chúng ta sẽ khám phá Pointer, Garbage Collection, và Memory Leaks & Profiling với độ chi tiết cao hơn, kèm theo các ví dụ phức tạp và phân tích.

1. Pointer (`&` và `*`) - Hiểu sâu và ứng dụng thực tế

Hiểu sâu về Pointer:

Pointer trong Go không chỉ là công cụ để "truyền tham chiếu", mà còn liên quan chặt chẽ đến escape analysis và cách Go quản lý bộ nhớ.
Escape Analysis: Trình biên dịch Go quyết định biến được cấp phát trên stack hay heap. Nếu một biến được truyền qua pointer và "thoát" khỏi phạm vi stack (ví dụ: trả về từ hàm), nó sẽ được cấp phát trên heap.

Ví dụ nâng cao:

package main

import "fmt"

type LargeStruct struct {
    Data [1000]int // Struct lớn để minh họa
}

func noEscape(s LargeStruct) {
    s.Data[0] = 42 // Copy toàn bộ struct, không dùng pointer
}

func withPointer(s *LargeStruct) {
    s.Data[0] = 42 // Chỉ truyền địa chỉ, không copy
}

func escapePointer() *LargeStruct {
    s := LargeStruct{}
    return &s // s "thoát" khỏi stack, được cấp phát trên heap
}

func main() {
    s := LargeStruct{}
    noEscape(s)        // Stack allocation
    withPointer(&s)    // Stack allocation (vì không thoát)
    p := escapePointer() // Heap allocation
    fmt.Println(p.Data[0])
}

Phân tích:

noEscape: Truyền giá trị, copy toàn bộ struct (1000 int ≈ 8KB trên 64-bit). Không hiệu quả với dữ liệu lớn.
withPointer: Truyền pointer, chỉ 8 byte (địa chỉ). Hiệu quả hơn, nhưng vẫn trên stack nếu không thoát.
escapePointer: Trả về pointer, buộc cấp phát trên heap, ảnh hưởng đến GC.

Ứng dụng thực tế:

Mutex và Pointer: Trong lập trình đồng thời, pointer thường được dùng với sync.Mutex để bảo vệ dữ liệu.

package main

import (
    "fmt"
    "sync"
)

type Counter struct {
    mu    sync.Mutex
    value int
}

func (c *Counter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func main() {
    c := &Counter{} // Pointer để chia sẻ giữa goroutine
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            c.Inc()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(c.value) // 100
}

Nil Pointer Panic: Pointer có thể là nil, cần kiểm tra cẩn thận:

var p *int
*p = 42 // Panic: nil pointer dereference

Best Practices:

Chỉ dùng pointer khi cần thay đổi dữ liệu gốc hoặc tối ưu hiệu suất.
Tránh lạm dụng pointer với dữ liệu nhỏ (int, bool), vì copy thường rẻ hơn quản lý pointer.
Hiểu escape analysis qua lệnh go build -gcflags="-m".

2. Garbage Collection (GC) - Cơ chế nội tại và tối ưu hóa

Cơ chế chi tiết:

Go dùng Tri-color Mark-and-Sweep GC:
- Black: Đã được đánh dấu, vẫn đang sử dụng.
- Grey: Đang chờ kiểm tra tham chiếu.
- White: Không được tham chiếu, sẽ bị thu hồi.
Write Barrier: Đảm bảo tính chính xác khi GC chạy đồng thời với chương trình (concurrent).
Pacing Algorithm: Từ Go 1.5, GC tự điều chỉnh tần suất dựa trên GOGC và tải ứng dụng.

Tối ưu hóa GC:

Giảm áp lực GC:
- Tránh cấp phát heap không cần thiết (dùng stack khi có thể).
- Tái sử dụng bộ nhớ với sync.Pool cho các đối tượng tạm thời.
Đo lường hiệu suất GC:

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    start := time.Now()
    var m runtime.MemStats

    // Tạo áp lực cho GC
    for i := 0; i < 1000000; i++ {
        _ = make([]byte, 1024) // Cấp phát 1KB mỗi lần
    }

    runtime.ReadMemStats(&m)
    fmt.Printf("HeapAlloc: %v bytes\n", m.HeapAlloc)
    fmt.Printf("GCCycles: %v\n", m.NumGC)
    fmt.Printf("Time: %v\n", time.Since(start))
}

Ứng dụng thực tế:

sync.Pool để giảm cấp phát:

package main

import (
    "fmt"
    "sync"
)

var pool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func main() {
    buf := pool.Get().([]byte) // Lấy từ pool
    buf[0] = 42
    pool.Put(buf) // Trả lại pool
    fmt.Println("Done")
}

Giảm cấp phát lặp lại, đặc biệt trong server xử lý request lớn.

Tuning GOGC:

High Throughput: GOGC=off (tắt GC, dùng thủ công) hoặc GOGC=1000.
Low Latency: GOGC=10, GC chạy thường xuyên hơn.

Debug GC:

Dùng runtime/debug để ghi log:

import "runtime/debug"
debug.SetGCPercent(50) // Tương đương GOGC=50

3. Memory Leaks & Profiling (`pprof`) - Phân tích chuyên sâu

Nguyên nhân Memory Leak nâng cao:

Goroutine Leak: Goroutine không thoát do channel bị chặn hoặc context không hủy.
Slice/Map Growth: Slice giữ tham chiếu cũ khi cắt (do capacity không giảm).
Finalizer Misuse: Dùng runtime.SetFinalizer không đúng cách.

Ví dụ Goroutine Leak:

package main

import (
    "fmt"
    "time"
)

func leakyGoroutine() {
    ch := make(chan int)
    go func() {
        for range ch { // Chờ mãi vì ch không đóng
        }
    }()
}

func main() {
    for i := 0; i < 1000; i++ {
        leakyGoroutine()
    }
    time.Sleep(1 * time.Second)
    fmt.Println("Goroutines:", runtime.NumGoroutine()) // ~1000
}

Sửa bằng Context:

package main

import (
    "context"
    "fmt"
    "time"
)

func fixedGoroutine(ctx context.Context) {
    ch := make(chan int)
    go func() {
        select {
        case <-ch:
        case <-ctx.Done(): // Thoát khi context hủy
        }
    }()
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    for i := 0; i < 1000; i++ {
        fixedGoroutine(ctx)
    }
    cancel() // Hủy tất cả goroutine
    time.Sleep(1 * time.Second)
    fmt.Println("Goroutines:", runtime.NumGoroutine()) // Gần 1
}

Profiling với pprof:

Heap Profile:
- Chạy: go tool pprof http://localhost:6060/debug/pprof/heap.
- Dùng list <function> để xem chi tiết cấp phát trong hàm.
Goroutine Profile:
- Chạy: go tool pprof http://localhost:6060/debug/pprof/goroutine.
- Xác định goroutine bị treo qua stack trace.
Trace:
- Chạy: curl -o trace.out http://localhost:6060/debug/pprof/trace?seconds=5.
- Mở: go tool trace trace.out để xem timeline.

Ví dụ thực tế với pprof:

package main

import (
    "net/http"
    _ "net/http/pprof"
)

func expensive() {
    for i := 0; i < 1000000; i++ {
        _ = make([]byte, 1024)
    }
}

func main() {
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()
    for {
        expensive()
    }
}

Chạy chương trình, sau đó dùng go tool pprof http://localhost:6060/debug/pprof/heap.
Kết quả sẽ chỉ ra expensive cấp phát quá nhiều bộ nhớ.

Best Practices:

Dùng context để kiểm soát goroutine.
Kiểm tra capacity của slice khi cắt: s = s[:0:0] để reset.
Tích hợp pprof vào CI/CD để phát hiện leak sớm.

Kết luận

Pointer: Hiểu escape analysis và tối ưu cấp phát.
GC: Tối ưu qua sync.Pool và điều chỉnh GOGC.
Profiling: Dùng pprof để debug chuyên sâu, kết hợp context để tránh leak.

PreviousSession NextHandle Error

Last updated 3 months ago

1. Pointer (& và *) - Hiểu sâu và ứng dụng thực tế

2. Garbage Collection (GC) - Cơ chế nội tại và tối ưu hóa

3. Memory Leaks & Profiling (pprof) - Phân tích chuyên sâu

Kết luận

1. Pointer (`&` và `*`) - Hiểu sâu và ứng dụng thực tế

3. Memory Leaks & Profiling (`pprof`) - Phân tích chuyên sâu