golang框架在高并发场景中的性能调优策略

func main() {
    // 创建一个带有 10 个 worker 的池
    pool := &sync.Pool{New: func() interface{} { return new(Worker) }}
    
    // 在池中并行执行任务
    for i := 10; i >= 0; i-- {
        // 从池中获取 worker
        w := pool.Get().(*Worker)
        defer pool.Put(w)
        
        // 并行并发执行
        go func(w *Worker, i int) {
            w.Do(i)
        }(w, i)
    }
}

type Worker struct{}

func (w *Worker) Do(i int) {
    // 实际处理逻辑
}

package main

import (
    "sync"
    "runtime"
)

func main() {
    // 创建一个 Goroutine 池
    var wg sync.WaitGroup
    var pool = make(chan func(), runtime.NumCPU()*2)

    // 将要执行的任务添加到池中
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        pool <- func() {
            defer wg.Done()
            // 实际处理逻辑
        }
    }

    // 关闭通道，等待任务执行完成
    close(pool)
    wg.Wait()
}

type Cache struct {
    mu sync.Mutex
    data map[string]interface{}
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()
    if val, ok := c.data[key]; ok {
        return val, true
    }
    return nil, false
}

func (c *Cache) Set(key string, val interface{}) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = val
}