一、并发优化

1.1 锁竞争优化
锁竞争是并发性能的主要瓶颈，优化核心在于减少临界区范围和竞争频率。

读写分离 (sync.RWMutex)
适用于读多写少的场景。RWMutex 允许多个读锁并存，但写锁独占。

type ConfigCache struct {
    sync.RWMutex
    m map[string]string
}
func (c *ConfigCache) Get(key string) string {
    c.RLock()
    defer c.RUnlock()
    return c.m[key]
}

原子操作 (sync/atomic)
对整数、指针等简单类型的操作，使用 atomic 原子指令，性能远超互斥锁。

type AtomicCounter struct {
    val int64
}
func (c *AtomicCounter) Add(delta int64) {
    atomic.AddInt64(&c.val, delta)
}

无锁通信
遵循 “通过通信共享内存” 的原则，使用 channel 将数据的不同操作转移至单个 goroutine 处理。

type CounterActor struct {
    ch     chan func()
    value  int64
}
func NewCounterActor() *CounterActor {
    ca := &CounterActor{ch: make(chan func())}
    go func() {
        for f := range ca.ch { f() }
    }()
    return ca
}
func (ca *CounterActor) Increment() {
    ca.ch <- func() { ca.value++ }
}

减小锁粒度
将大锁拆分为多个小锁，降低冲突概率。

1.2 并发控制

goroutine 生命周期管理
避免无限制创建 goroutine，使用 worker pool 控制并发量。

type Pool struct {
    work chan func()
    wait sync.WaitGroup
}
func NewPool(size int) *Pool {
    p := &Pool{work: make(chan func())}
    p.wait.Add(size)
    for i := 0; i < size; i++ {
        go func() {
            for w := range p.work { w() }
            p.wait.Done()
        }()
    }
    return p
}

Context 传递取消信号
使用 context.Context 在调用链中传递取消信号和超时，及时释放资源。

func Process(ctx context.Context) error {
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    resultCh := make(chan error)
    go func() { resultCh <- expensiveOperation(ctx) }()
    select {
    case err := <-resultCh:
        return err
    case <-ctx.Done():
        return ctx.Err()
    }
}

二、内存与GC优化

2.1 减少分配与复用
使用 sync.Pool 缓存高频创建和回收的对象
sync.Pool 适用于缓存高频创建的临时对象，减轻 GC 压力。注意对象可能被随时回收，取出后需重置状态。Put 表示当一个协程用完一个对象后，可以把它放回池里。Get 则表示当需要新对象时，协程首先尝试从池里拿。如果池是空的，则会调用New 函数创建一个新的。

var jsonEncoderPool = sync.Pool{
    New: func() interface{} {
        enc := json.NewEncoder(nil)
        return enc
    },
}

func GetJSONEncoder(w io.Writer) *json.Encoder {
    enc := jsonEncoderPool.Get().(*json.Encoder)
    enc.Reset(w) // 重置
    return enc
}

func PutJSONEncoder(enc *json.Encoder) {
    jsonEncoderPool.Put(enc)
}

func encodeData(w http.ResponseWriter, data interface{}) error {
    enc := GetJSONEncoder(w)
    defer PutJSONEncoder(enc) // 用完后放回
    return enc.Encode(data)
}

预分配切片和映射
为切片预设容量，避免多次重分配与复制。

// 切片预分配
size := 1000
s := make([]int, 0, size)
m := make(map[string]int, size)

2.2 减少堆上内存分配
编译器通过逃逸分析决定变量分配在栈还是堆。减少指针的使用可以降低堆分配和 GC 扫描开销。可通过 go build -gcflags=”-m” 分析逃逸情况。

三、数据结构和配置优化

3.1 使用正确的数据结构
使用具体类型 map（如 map[string]int）而非 map[string]interface{}，以避免类型断言的开销。在元素较少时，slice 遍历可能比 map 查找更快。

3.2 高性能的 JSON 处理
标准库 encoding/json 性能有提升空间，json-iterator/go 速度更快。

import jsoniter "github.com/json-iterator/go"
var json = jsoniter.ConfigCompatibleWithStandardLibrary
json.Marshal(&data)

3.3 字符串拼接优化
使用 strings.Builder 或 bytes.Buffer，避免使用 + 拼接。

var builder strings.Builder
for _, s := range strs {
    builder.WriteString(s)
}
result := builder.String()

四、性能分析

4.1 使用 pprof
集成 net/http/pprof 后，可通过 Web 接口或命令行工具采集分析数据。

 采集30秒CPU画像
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
 分析堆内存
go tool pprof http://localhost:6060/debug/pprof/heap

在交互界面使用 top、list 命令定位热点，web 命令生成可视化火焰图。

4.2 使用 trace
对于调度、GC、网络阻塞等延迟问题，go tool trace 命令定位问题。

4.3 竞态检测
运行 go test -race 检测数据竞争。

五、编译与部署优化

5.1 编译优化
通过链接器标志减少生成的二进制大小。

go build -ldflags="-s -w" -o app ./cmd

-s 省略符号表，-w 省略 DWARF 调试信息。