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

}