Tối ưu Hiệu suất trong Go - Làm cho Code Chạy Nhanh hơn! 🚀

Chào mừng bạn đến với bài học về tối ưu hiệu suất trong Go! Trong bài học này, chúng ta sẽ tìm hiểu cách làm cho code của bạn chạy nhanh và hiệu quả hơn.

Quản lý Bộ nhớ 💾

1. Cấp phát Bộ nhớ

// ✅ Đúng: Cấp phát trước dung lượng
users := make([]User, 0, 100)

// ❌ Sai: Cấp phát động
var users []User

💡 Giải thích:

• Cấp phát trước giúp tránh việc mở rộng slice
• Giảm số lần cấp phát bộ nhớ
• Tăng hiệu suất xử lý

2. Memory Pool

type Pool struct {
    sync.Pool
}

func NewPool() *Pool {
    return &Pool{
        Pool: sync.Pool{
            New: func() interface{} {
                return make([]byte, 1024)
            },
        },
    }
}

💡 Giải thích:

• Tái sử dụng bộ nhớ
• Giảm áp lực lên garbage collector
• Hiệu quả cho các đối tượng nhỏ

Quản lý Goroutines 🔄

1. Worker Pool

type WorkerPool struct {
    jobs    chan func()
    results chan interface{}
    wg      sync.WaitGroup
}

func NewWorkerPool(numWorkers int) *WorkerPool {
    pool := &WorkerPool{
        jobs:    make(chan func(), 100),
        results: make(chan interface{}, 100),
    }
    
    pool.wg.Add(numWorkers)
    for i := 0; i < numWorkers; i++ {
        go func() {
            defer pool.wg.Done()
            for job := range pool.jobs {
                result := job()
                pool.results <- result
            }
        }()
    }
    
    return pool
}

💡 Giải thích:

• Quản lý số lượng goroutine
• Tái sử dụng goroutine
• Tránh tạo quá nhiều goroutine

2. Tránh Goroutine Leak

func processWithTimeout(ctx context.Context, data []byte) error {
    done := make(chan error)
    go func() {
        done <- process(data)
    }()
    
    select {
    case err := <-done:
        return err
    case <-ctx.Done():
        return ctx.Err()
    }
}

💡 Giải thích:

• Sử dụng context để hủy bỏ
• Tránh goroutine bị treo
• Quản lý tài nguyên hiệu quả

Tối ưu Database 🗄️

1. Connection Pool

type DB struct {
    *sql.DB
}

func NewDB(dsn string) (*DB, error) {
    db, err := sql.Open("postgres", dsn)
    if err != nil {
        return nil, err
    }
    
    // Cấu hình connection pool
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(5 * time.Minute)
    
    return &DB{db}, nil
}

💡 Giải thích:

• Quản lý số lượng kết nối
• Tái sử dụng kết nối
• Giảm tải cho database

2. Tối ưu Query

// ✅ Đúng: Sử dụng prepared statements
stmt, err := db.Prepare("SELECT * FROM users WHERE id = $1")
if err != nil {
    return err
}
defer stmt.Close()

// ❌ Sai: Nối chuỗi SQL
query := fmt.Sprintf("SELECT * FROM users WHERE id = %d", id)

💡 Giải thích:

• Tránh SQL injection
• Tái sử dụng query plan
• Tăng hiệu suất

Caching 🚀

1. Cache trong Bộ nhớ

type Cache struct {
    sync.RWMutex
    items map[string]interface{}
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.RLock()
    defer c.RUnlock()
    item, exists := c.items[key]
    return item, exists
}

💡 Giải thích:

• Truy xuất nhanh dữ liệu
• Giảm tải cho database
• Sử dụng RWMutex để đồng bộ

2. Distributed Cache

type RedisCache struct {
    client *redis.Client
}

func (c *RedisCache) Get(key string) (string, error) {
    return c.client.Get(context.Background(), key).Result()
}

💡 Giải thích:

• Cache phân tán
• Chia sẻ dữ liệu giữa các server
• Tăng khả năng mở rộng

Tối ưu HTTP 🌐

1. Response Pooling

var responsePool = sync.Pool{
    New: func() interface{} {
        return &Response{}
    },
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    resp := responsePool.Get().(*Response)
    defer responsePool.Put(resp)
    
    // Xử lý yêu cầu
    resp.Data = processData()
    json.NewEncoder(w).Encode(resp)
}

💡 Giải thích:

• Tái sử dụng đối tượng response
• Giảm áp lực lên garbage collector
• Tăng hiệu suất xử lý

2. Keep-Alive Connections

client := &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        100,
        IdleConnTimeout:     90 * time.Second,
        DisableCompression:  true,
    },
}

💡 Giải thích:

• Duy trì kết nối
• Giảm overhead tạo kết nối
• Tối ưu hiệu suất

Xử lý JSON 📝

1. JSON Marshaling

// ✅ Đúng: Sử dụng json.RawMessage
type DynamicResponse struct {
    Type    string          `json:"type"`
    Payload json.RawMessage `json:"payload"`
}

// ❌ Sai: Sử dụng interface{}
type DynamicResponse struct {
    Type    string      `json:"type"`
    Payload interface{} `json:"payload"`
}

💡 Giải thích:

• Xử lý JSON hiệu quả
• Tránh reflection
• Tăng hiệu suất

2. Custom JSON Marshaling

type CustomTime time.Time

func (t CustomTime) MarshalJSON() ([]byte, error) {
    return []byte(`"` + time.Time(t).Format(time.RFC3339) + `"`), nil
}

💡 Giải thích:

• Tùy chỉnh định dạng JSON
• Tối ưu hiệu suất
• Dễ dàng mở rộng

Profiling 🔍

1. CPU Profiling

import "runtime/pprof"

func main() {
    f, _ := os.Create("cpu.prof")
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()
    
    // Code của bạn ở đây
}

💡 Giải thích:

• Phân tích CPU usage
• Tìm bottlenecks
• Tối ưu hiệu suất

2. Memory Profiling

import "runtime/pprof"

func main() {
    f, _ := os.Create("mem.prof")
    pprof.WriteHeapProfile(f)
    f.Close()
}

💡 Giải thích:

• Phân tích bộ nhớ
• Tìm memory leaks
• Tối ưu sử dụng bộ nhớ

Benchmarking 📊

1. Viết Benchmarks

func BenchmarkProcess(b *testing.B) {
    data := generateTestData()
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        process(data)
    }
}

💡 Giải thích:

• Đo hiệu suất code
• So sánh các giải pháp
• Tối ưu hiệu suất

2. Benchmarking HTTP

func BenchmarkHTTP(b *testing.B) {
    server := setupTestServer()
    defer server.Close()
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        resp, err := http.Get(server.URL)
        if err != nil {
            b.Fatal(err)
        }
        resp.Body.Close()
    }
}

💡 Giải thích:

• Đo hiệu suất HTTP
• Kiểm tra server
• Tối ưu API

Best Practices (Cách sử dụng tốt nhất) ✅

1. Sử dụng profiling tools

   // ✅ Đúng
   import "runtime/pprof"
   
   // ❌ Sai
   // Không sử dụng profiling

2. Tối ưu memory allocation

   // ✅ Đúng
   users := make([]User, 0, 100)
   
   // ❌ Sai
   var users []User

3. Quản lý goroutines

   // ✅ Đúng
   ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
   defer cancel()
   
   // ❌ Sai
   go process()  // Không có timeout

4. Sử dụng connection pooling

   // ✅ Đúng
   db.SetMaxOpenConns(25)
   
   // ❌ Sai
   // Không giới hạn kết nối

Tiếp theo 🎯

Trong các bài học tiếp theo, chúng ta sẽ:

• Tìm hiểu về security
• Học cách tối ưu database
• Khám phá các kỹ thuật nâng cao
• Thực hành với các dự án thực tế

💡 Lời khuyên: Hãy nhớ rằng tối ưu hiệu suất là một quá trình liên tục. Đo lường, phân tích và cải thiện code của bạn thường xuyên để đạt được hiệu suất tốt nhất!