Go语言AI客户端实战：goroutine并发调用多模型API性能压测

Mo ta bai viet SEO

Gioi thieu chung

Van de thuc te: Dinh dang he thong RAG doanh nghiep

Yeucau_ngay = 10,000 requests
Thoi gian xu ly trung binh = 3 giay/request
Neu goi sequential: 10,000 × 3s = 30,000s = 8.3 gio
Neu goi concurrent voi 50 goroutine: 30,000s / 50 = 600s = 10 phut

Tai sao chon Go cho AI API Client?

Cai dat moi truong va cau hinh

1. Khoi tao project Go

mkdir ai-client-benchmark && cd ai-client-benchmark
go mod init ai-client-benchmark
go get github.com/google/uuid

2. Cau hinh HolySheep AI API

3. Cau hinh HTTP Client toi uu

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "sync"
    "time"
)

const (
    BaseURL = "https://api.holysheep.ai/v1"
    APIKey  = "YOUR_HOLYSHEEP_API_KEY"
)

type HTTPClient struct {
    client  *http.Client
    baseURL string
    apiKey  string
}

func NewHTTPClient() *HTTPClient {
    return &HTTPClient{
        client: &http.Client{
            Timeout: 30 * time.Second,
            Transport: &http.Transport{
                MaxIdleConns:        100,
                MaxIdleConnsPerHost: 100,
                IdleConnTimeout:     90 * time.Second,
                DisableKeepAlives:   false,
            },
        },
        baseURL: BaseURL,
        apiKey:  APIKey,
    }
}

func (c *HTTPClient) doRequest(ctx context.Context, method, endpoint string, body interface{}) ([]byte, int, error) {
    // Implementation details
    return nil, 0, nil
}

Xay dung Multi-Model AI Client voi Goroutine

Kien truc tong the

┌─────────────────────────────────────────────────────────────┐
│                    Main Application                          │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │  User       │  │  User       │  │  User       │          │
│  │  Request 1  │  │  Request 2  │  │  Request N  │          │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘          │
│         │                │                │                  │
│  ┌──────▼────────────────▼────────────────▼──────┐          │
│  │              Request Channel                     │          │
│  │                 (buffered 1000)                 │          │
│  └──────────────────────┬────────────────────────┘          │
├─────────────────────────┼────────────────────────────────────┤
│                         │                                     │
│  ┌──────────┬───────────┼───────────┬──────────┐            │
│  │          │           │           │          │            │
│  ▼          ▼           ▼           ▼          ▼            │
│ ┌───┐     ┌───┐       ┌───┐       ┌───┐     ┌───┐          │
│ │ G1│     │ G2│  ...  │ G10│ ...  │ G99│    │G100│          │
│ │   │     │   │       │    │      │    │     │   │          │
│ └───┘     └───┘       └───┘       └───┘     └───┘          │
│  Goroutines (concurrent workers)                            │
│                         │                                     │
│  ┌─────────────────────┴────────────────────┐                │
│  │         Model Router                      │                │
│  │  ┌─────────┬─────────┬─────────┬────────┐ │                │
│  │  │ GPT-4.1 │Claude 4.5│Gemini 2.5│DeepSeek│ │               │
│  │  └─────────┴─────────┴─────────┴────────┘ │                │
│  └─────────────────────┬────────────────────┘                │
└────────────────────────┼────────────────────────────────────┘
                          │
                     HolySheep AI API
                   (https://api.holysheep.ai/v1)

1. dinh nghia cau truc du lieu

package main

import (
    "context"
    "sync"
    "time"
)

// ModelConfig cau hinh cho tung model
type ModelConfig struct {
    Name       string
    Endpoint   string
    MaxTokens  int
    Timeout    time.Duration
}

// AIModelResponse phan hoi tu AI model
type AIModelResponse struct {
    Model       string
    Content     string
    LatencyMs   int64
    Tokens      int
    Err         error
}

// BatchRequest yeu cau batch
type BatchRequest struct {
    ID      string
    Query   string
    Models  []string
    Timeout time.Duration
}

// BatchResult ket qua batch
type BatchResult struct {
    RequestID   string
    Responses   map[string]AIModelResponse
    TotalTimeMs int64
}

// MultiModelClient client goi nhieu model cung luc
type MultiModelClient struct {
    httpClient   *HTTPClient
    modelConfigs map[string]ModelConfig
    workerCount  int
    requestChan  chan BatchRequest
    resultChan   chan BatchResult
    wg           sync.WaitGroup
    mu           sync.RWMutex
}

// NewMultiModelClient tao moi multi-model client
func NewMultiModelClient(workerCount int) *MultiModelClient {
    client := &MultiModelClient{
        httpClient:  NewHTTPClient(),
        workerCount: workerCount,
        requestChan: make(chan BatchRequest, 1000),
        resultChan:  make(chan BatchResult, 1000),
        modelConfigs: map[string]ModelConfig{
            "gpt-4.1": {
                Name:      "GPT-4.1",
                Endpoint:  "/chat/completions",
                MaxTokens: 4096,
                Timeout:   30 * time.Second,
            },
            "claude-sonnet-4.5": {
                Name:      "Claude Sonnet 4.5",
                Endpoint:  "/chat/completions",
                MaxTokens: 8192,
                Timeout:   45 * time.Second,
            },
            "gemini-2.5-flash": {
                Name:      "Gemini 2.5 Flash",
                Endpoint:  "/chat/completions",
                MaxTokens: 8192,
                Timeout:   15 * time.Second,
            },
            "deepseek-v3.2": {
                Name:      "DeepSeek V3.2",
                Endpoint:  "/chat/completions",
                MaxTokens: 4096,
                Timeout:   20 * time.Second,
            },
        },
    }
    return client
}

2. Implementation goroutine worker pool

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "runtime"
    "time"
)

// StartWorkers khoi dong worker pool
func (c *MultiModelClient) StartWorkers(ctx context.Context) {
    for i := 0; i < c.workerCount; i++ {
        c.wg.Add(1)
        go c.worker(ctx, i)
    }
    fmt.Printf("[INFO] Da khoi dong %d goroutine workers\n", c.workerCount)
}

// worker xu ly yeu cau tu channel
func (c *MultiModelClient) worker(ctx context.Context, workerID int) {
    defer c.wg.Done()
    
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("[WORKER-%d] Da dung\n", workerID)
            return
        case req, ok := <-c.requestChan:
            if !ok {
                fmt.Printf("[WORKER-%d] Channel dong\n", workerID)
                return
            }
            c.processRequest(req)
        }
    }
}

// processRequest xu ly mot yeu cau batch
func (c *MultiModelClient) processRequest(req BatchRequest) {
    startTime := time.Now()
    
    // Tao context voi timeout
    ctx, cancel := context.WithTimeout(context.Background(), req.Timeout)
    defer cancel()
    
    // Su dung semaphore de gioi han so luong model goi cung luc
    semaphore := make(chan struct{}, 3) // toi da 3 model cung luc
    
    var wg sync.WaitGroup
    responses := make(map[string]AIModelResponse)
    var mu sync.Mutex
    
    for _, modelName := range req.Models {
        wg.Add(1)
        go func(model string) {
            defer wg.Done()
            
            // Acquire semaphore
            semaphore <- struct{}{}
            defer func() { <-semaphore }()
            
            resp := c.callModel(ctx, model, req.Query)
            
            mu.Lock()
            responses[model] = resp
            mu.Unlock()
        }(modelName)
    }
    
    wg.Wait()
    
    result := BatchResult{
        RequestID:   req.ID,
        Responses:   responses,
        TotalTimeMs: time.Since(startTime).Milliseconds(),
    }
    
    c.resultChan <- result
}

// callModel goi mot model cu the
func (c *MultiModelClient) callModel(ctx context.Context, modelName, query string) AIModelResponse {
    startTime := time.Now()
    
    config, ok := c.modelConfigs[modelName]
    if !ok {
        return AIModelResponse{
            Model: modelName,
            Err:   fmt.Errorf("model khong ho tro: %s", modelName),
        }
    }
    
    // Map ten model sang model ID cua HolySheep
    modelID := mapToModelID(modelName)
    
    // Tao request body
    reqBody := map[string]interface{}{
        "model": modelID,
        "messages": []map[string]string{
            {"role": "user", "content": query},
        },
        "max_tokens": config.MaxTokens,
        "temperature": 0.7,
    }
    
    jsonBody, err := json.Marshal(reqBody)
    if err != nil {
        return AIModelResponse{Model: modelName, Err: err}
    }
    
    // Tao HTTP request
    req, err := http.NewRequestWithContext(ctx, "POST", 
        c.httpClient.baseURL+config.Endpoint, 
        bytes.NewBuffer(jsonBody))
    if err != nil {
        return AIModelResponse{Model: modelName, Err: err}
    }
    
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+c.httpClient.apiKey)
    
    // Thuc hien request
    resp, err := c.httpClient.client.Do(req)
    if err != nil {
        return AIModelResponse{Model: modelName, Err: err}
    }
    defer resp.Body.Close()
    
    // Doc response
    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return AIModelResponse{Model: modelName, Err: err}
    }
    
    latencyMs := time.Since(startTime).Milliseconds()
    
    // Trich xuat content
    content := ""
    if choices, ok := result["choices"].([]interface{}); ok && len(choices) > 0 {
        if choice, ok := choices[0].(map[string]interface{}); ok {
            if msg, ok := choice["message"].(map[string]interface{}); ok {
                content, _ = msg["content"].(string)
            }
        }
    }
    
    return AIModelResponse{
        Model:     modelName,
        Content:   content,
        LatencyMs: latencyMs,
        Err:       nil,
    }
}

// mapToModelID map ten model sang model ID cua HolySheep
func mapToModelID(modelName string) string {
    mapping := map[string]string{
        "gpt-4.1":          "gpt-4.1",
        "claude-sonnet-4.5": "claude-sonnet-4-5",
        "gemini-2.5-flash":  "gemini-2.5-flash",
        "deepseek-v3.2":     "deepseek-v3.2",
    }
    return mapping[modelName]
}

3. Benchmark thuc te

package main

import (
    "context"
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

// BenchmarkResult ket qua benchmark
type BenchmarkResult struct {
    TotalRequests    int64
    SuccessCount     int64
    ErrorCount       int64
    TotalLatencyMs   int64
    MinLatencyMs     int64
    MaxLatencyMs     int64
    AvgLatencyMs     int64
    RequestsPerSec   float64
    P50LatencyMs     int64
    P95LatencyMs     int64
    P99LatencyMs     int64
}

// RunBenchmark chay benchmark
func (c *MultiModelClient) RunBenchmark(duration time.Duration, concurrency int) BenchmarkResult {
    ctx, cancel := context.WithTimeout(context.Background(), duration)
    defer cancel()
    
    c.StartWorkers(ctx)
    
    var (
        totalRequests  int64
        successCount   int64
        errorCount     int64
        totalLatency   int64
        minLatency     int64 = int64(1<<63 - 1) // max int64
        maxLatency     int64
        latencies      []int64
        latenciesMu    sync.Mutex
    )
    
    // Tinh toan so request can gui
    requestsPerWorker := 100
    totalReqs := concurrency * requestsPerWorker
    
    fmt.Printf("[BENCHMARK] Bat dau: %d requests, %d concurrency, %v duration\n", 
        totalReqs, concurrency, duration)
    
    startTime := time.Now()
    
    // Gui requests
    var wg sync.WaitGroup
    for i := 0; i < totalReqs; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            
            req := BatchRequest{
                ID:     fmt.Sprintf("bench-%d", id),
                Query:  "Giai thich khai niem goroutine trong Go?",
                Models: []string{"gpt-4.1", "gemini-2.5-flash", "deepseek-v3.2"},
                Timeout: 60 * time.Second,
            }
            
            reqStart := time.Now()
            c.requestChan <- req
            
            // Doi ket qua
            select {
            case result := <-c.resultChan:
                latency := result.TotalTimeMs
                atomic.AddInt64(&totalRequests, 1)
                atomic.AddInt64(&totalLatency, latency)
                
                // Cap nhat min/max
                for _, resp := range result.Responses {
                    if resp.Err != nil {
                        atomic.AddInt64(&errorCount, 1)
                        break
                    }
                    atomic.AddInt64(&successCount, 1)
                }
                
                // Luu latencies
                latenciesMu.Lock()
                latencies = append(latencies, latency)
                if latency < minLatency {
                    minLatency = latency
                }
                if latency > maxLatency {
                    maxLatency = latency
                }
                latenciesMu.Unlock()
                
                _ = reqStart
                
            case <-ctx.Done():
                return
            }
        }(i)
    }
    
    wg.Wait()
    
    // Dong channels
    close(c.requestChan)
    c.wg.Wait()
    
    elapsed := time.Since(startTime)
    
    // Tinh percentile
    avgLatency := int64(0)
    if totalRequests > 0 {
        avgLatency = totalLatency / totalRequests
    }
    
    // Sort latencies for percentile calculation
    // (Implementation omitted for brevity)
    
    rps := float64(totalRequests) / elapsed.Seconds()
    
    return BenchmarkResult{
        TotalRequests:   totalRequests,
        SuccessCount:    successCount,
        ErrorCount:      errorCount,
        TotalLatencyMs:  totalLatency,
        MinLatencyMs:    minLatency,
        MaxLatencyMs:    maxLatency,
        AvgLatencyMs:    avgLatency,
        RequestsPerSec:  rps,
    }
}

// In ket qua benchmark
func (r BenchmarkResult) Print() {
    fmt.Println("\n========== BENCHMARK RESULTS ==========")
    fmt.Printf("Tong requests:          %d\n", r.TotalRequests)
    fmt.Printf("Thanh cong:             %d (%.2f%%)\n", r.SuccessCount, 
        float64(r.SuccessCount)/float64(r.TotalRequests)*100)
    fmt.Printf("Loi:                    %d\n", r.ErrorCount)
    fmt.Printf("Avg Latency:            %d ms\n", r.AvgLatencyMs)
    fmt.Printf("Min Latency:            %d ms\n", r.MinLatencyMs)
    fmt.Printf("Max Latency:            %d ms\n", r.MaxLatencyMs)
    fmt.Printf("Requests/Second:        %.2f\n", r.RequestsPerSec)
    fmt.Println("========================================")
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    
    client := NewMultiModelClient(50)
    
    // Chay benchmark
    result := client.RunBenchmark(30*time.Second, 50)
    result.Print()
}

Ket qua benchmark thuc te

Cau hinh may test

CPU: AMD Ryzen 9 7950X (16 cores)
RAM: 64GB DDR5
Network: 1Gbps
OS: Ubuntu 22.04 LTS
Go version: 1.22

Ket qua chi tiet

So sanh latency giua cac model

Loi thuong gap va cach khac phuc

Lỗi 1: Context Deadline Exceeded

context deadline exceeded: client timeout 30s exceeded

func handleContextDeadlineExceeded(ctx context.Context, modelName string) error {
    select {
    case <-ctx.Done():
        if ctx.Err() == context.DeadlineExceeded {
            fmt.Printf("[ERROR] Model %s vuot qua thoi gian cho: 30s\n", modelName)
            // Retry voi exponential backoff
            return retryWithBackoff(ctx, modelName, 3)
        }
        return ctx.Err()
    default:
        return nil
    }
}

func retryWithBackoff(ctx context.Context, modelName string, maxRetries int) error {
    var lastErr error
    
    for attempt := 0; attempt < maxRetries; attempt++ {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-time.After(time.Duration(1<

socket: too many open files

import "syscall"

func increaseFileDescriptorLimit() {
    var rLimit syscall.Rlimit
    if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit); err != nil {
        fmt.Printf("[WARN] Khong the lay file descriptor limit: %v\n", err)
        return
    }
    
    // Tang limit len 100000
    newLimit := rLimit
    newLimit.Cur = 100000
    if newLimit.Cur < newLimit.Max {
        if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &newLimit); err != nil {
            fmt.Printf("[ERROR] Khong the tang file descriptor limit: %v\n", err)
            return
        }
        fmt.Printf("[INFO] Da tang file descriptor limit: %d -> %d\n", 
            rLimit.Cur, newLimit.Cur)
    }
}

# Kiem tra limit hien tai
ulimit -n

Tang tam thoi
ulimit -n 65535

Tang vinh vien (them vao /etc/security/limits.conf)
* soft nofile 65535
* hard nofile 65535

HTTP 429: rate limit exceeded

type RateLimiter struct {
    requests    chan struct{}
    interval    time.Duration
    mu          sync.Mutex
    lastRequest time.Time
}

func NewRateLimiter(requestsPerSecond int) *RateLimiter {
    return &RateLimiter{
        requests: make(chan struct{}, requestsPerSecond),
        interval: time.Second / time.Duration(requestsPerSecond),
    }
}

func (r *RateLimiter) Allow() {
    r.mu.Lock()
    defer r.mu.Unlock()
    
    now := time.Now()
    elapsed := now.Sub(r.lastRequest)
    
    if elapsed < r.interval {
        time.Sleep(r.interval - elapsed)
    }
    
    r.lastRequest = time.Now()
}

func (r *RateLimiter) Wait(ctx context.Context) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    case r.requests <- struct{}{}:
        go func() {
            time.Sleep(r.interval)
            <-r.requests
        }()
        return nil
    }
}

func (c *MultiModelClient) callModelRateLimited(ctx context.Context, modelName, query string) (AIModelResponse, error) {
    // HolySheep AI: 100 requests/second default
    limiter := NewRateLimiter(100)
    
    if err := limiter.Wait(ctx); err != nil {
        return AIModelResponse{}, err
    }
    
    return c.callModel(ctx, modelName, query), nil
}