性能优化

 1┌─ 代码层面优化
 2│  ├─ 内存优化
 3│  ├─ 并发优化  
 4│  ├─ 算法优化
 5│  └─ 编译器优化
 6│
 7├─ 运行时优化
 8│  ├─ GC 优化
 9│  ├─ 调度优化
10│  └─ 内存管理
11│
12├─ I/O 优化
13│  ├─ 网络优化
14│  ├─ 文件系统优化
15│  └─ 数据库优化
16│
17└─ 系统层面优化
18   ├─ 部署优化
19   ├─ 监控优化
20   └─ 硬件优化

 1// ❌ 避免在循环中频繁分配
 2for i := 0; i < 1000; i++ {
 3    data := make([]byte, 1024)  // 每次循环都分配
 4    // 使用 data...
 5}
 6
 7// ✅ 预分配或复用
 8buffer := make([]byte, 1024)
 9for i := 0; i < 1000; i++ {
10    // 复用 buffer
11}

 1var bufferPool = sync.Pool{
 2    New: func() interface{} {
 3        return bytes.NewBuffer(make([]byte, 0, 1024))
 4    },
 5}
 6
 7func getBuffer() *bytes.Buffer {
 8    return bufferPool.Get().(*bytes.Buffer)
 9}
10
11func putBuffer(buf *bytes.Buffer) {
12    buf.Reset()
13    bufferPool.Put(buf)
14}

1// ❌ 可能逃逸到堆
2func newUser() *User {
3    return &User{Name: "John"}  // 逃逸到堆
4}
5
6// ✅ 如果可能，让调用方分配
7func fillUser(u *User) {
8    u.Name = "John"
9}

 1// 小对象尽量在栈上分配
 2type Small struct {
 3    a, b int32
 4}
 5
 6// 编译器会优先在栈上分配
 7func process() {
 8    var s Small  // 栈分配
 9    // ...
10}

 1// ❌ 无限制创建 goroutine
 2for _, task := range tasks {
 3    go process(task)  // 可能创建太多 goroutine
 4}
 5
 6// ✅ 使用 worker pool
 7type WorkerPool struct {
 8    workers int
 9    tasks   chan Task
10}
11
12func (wp *WorkerPool) Start() {
13    for i := 0; i < wp.workers; i++ {
14        go wp.worker()
15    }
16}

 1// ❌ 粗粒度锁
 2var mu sync.Mutex
 3var data map[string]int
 4
 5func update(key string, value int) {
 6    mu.Lock()
 7    data[key] = value
 8    mu.Unlock()
 9}
10
11// ✅ 细粒度锁或分片锁
12type ShardedMap struct {
13    shards []map[string]int
14    locks  []sync.RWMutex
15}
16
17func (sm *ShardedMap) getShard(key string) int {
18    return int(fnv32(key)) % len(sm.shards)
19}

 1// ❌ 使用锁保护计数器
 2var count int
 3var mu sync.Mutex
 4
 5func increment() {
 6    mu.Lock()
 7    count++
 8    mu.Unlock()
 9}
10
11// ✅ 使用 atomic
12var count int64
13
14func increment() {
15    atomic.AddInt64(&count, 1)
16}

 1// ❌ 伪共享问题
 2type Data struct {
 3    a int64
 4    b int64  // 可能在同一缓存行
 5}
 6
 7// ✅ 缓存行对齐
 8type Data struct {
 9    a int64
10    _ [56]byte  // 填充，确保在不同缓存行
11    b int64
12}

1// 根据使用场景选择
2- 查找频繁 → map
3- 有序数据 → slice + 二分查找
4- 频繁插入删除 → linked list
5- 唯一性检查 → map 或 bitset

 1// ❌ 动态扩容
 2var users []User
 3for i := 0; i < 10000; i++ {
 4    users = append(users, User{})  // 多次扩容
 5}
 6
 7// ✅ 预分配
 8users := make([]User, 0, 10000)
 9for i := 0; i < 10000; i++ {
10    users = append(users, User{})
11}

 1// ❌ O(n²)
 2for i := 0; i < n; i++ {
 3    for j := 0; j < n; j++ {
 4        // 处理
 5    }
 6}
 7
 8// ✅ O(n log n) 或 O(n)
 9sort.Slice(data, func(i, j int) bool {
10    return data[i] < data[j]
11})

1// ❌ 乘除运算
2x := a * 2
3y := b / 2
4
5// ✅ 位运算
6x := a << 1  // 乘以2
7y := b >> 1  // 除以2

1// ❌ 单条操作
2for _, user := range users {
3    db.Insert(user)
4}
5
6// ✅ 批量操作
7db.BulkInsert(users)

 1// ❌ 无缓冲
 2file, _ := os.Open("data.txt")
 3buf := make([]byte, 1)
 4for {
 5    n, err := file.Read(buf)
 6    // ...
 7}
 8
 9// ✅ 带缓冲
10reader := bufio.NewReader(file)
11for {
12    line, err := reader.ReadString('\n')
13    // ...
14}

 1// ❌ 每次创建连接
 2func query() {
 3    db, _ := sql.Open(...)
 4    defer db.Close()
 5    // ...
 6}
 7
 8// ✅ 连接池
 9var db *sql.DB
10
11func init() {
12    db, _ = sql.Open(...)
13    db.SetMaxOpenConns(100)
14    db.SetMaxIdleConns(10)
15}

 1// ❌ 数据复制
 2func process(data []byte) []byte {
 3    result := make([]byte, len(data))
 4    copy(result, data)
 5    // 处理
 6    return result
 7}
 8
 9// ✅ 避免复制
10func processInPlace(data []byte) {
11    // 原地处理
12    for i := range data {
13        data[i] = data[i] + 1
14    }
15}

 1// 编译器会自动内联小函数
 2// 标记为 //go:noinline 可以阻止内联
 3func smallFunction(a, b int) int {
 4    return a + b  // 可能被内联
 5}
 6
 7//go:noinline
 8func largeFunction() {
 9    // 不会被内联
10}

1// 查看逃逸分析
2go build -gcflags="-m -l"
3
4// 输出会显示哪些变量逃逸到堆

 1// 边界检查消除
 2func sum(arr []int) int {
 3    s := 0
 4    for i := range arr {
 5        s += arr[i]  // 编译器可能消除边界检查
 6    }
 7    return s
 8}
 9
10// 编译时禁用边界检查
11// go build -gcflags="-B"

1// 1. 收集性能数据
2go test -cpuprofile=cpu.prof -bench=.
3
4// 2. 使用 PGO 编译
5go build -pgo=cpu.prof

 1// ❌ 字符串拼接
 2var result string
 3for i := 0; i < 1000; i++ {
 4    result += strconv.Itoa(i)
 5}
 6
 7// ✅ 使用 strings.Builder
 8var builder strings.Builder
 9for i := 0; i < 1000; i++ {
10    builder.WriteString(strconv.Itoa(i))
11}
12result := builder.String()

 1// ❌ 频繁转换
 2func process(s string) {
 3    b := []byte(s)  // 分配新内存
 4    // 处理 b
 5    s2 := string(b) // 再次分配
 6}
 7
 8// ✅ 统一使用 []byte
 9func process(b []byte) []byte {
10    // 原地处理
11    return b
12}

1// bytes 包操作 []byte，避免转换
2// ❌
3s := "hello"
4s = strings.ToUpper(s)
5
6// ✅
7b := []byte("hello")
8b = bytes.ToUpper(b)

1// 根据场景选择协议
2- REST/HTTP/1.1 → 简单，兼容性好
3- HTTP/2 → 多路复用，头部压缩
4- gRPC → 高性能，protobuf 编码
5- WebSocket → 实时双向通信

 1// 配置 HTTP 客户端
 2client := &http.Client{
 3    Transport: &http.Transport{
 4        MaxIdleConns:        100,
 5        MaxIdleConnsPerHost: 10,
 6        IdleConnTimeout:     90 * time.Second,
 7        // 启用 HTTP/2
 8        ForceAttemptHTTP2: true,
 9    },
10}

1// 选择合适的序列化格式
2- JSON → 通用，可读性好
3- Protobuf → 高效，二进制
4- MessagePack → 二进制 JSON
5- FlatBuffers → 零拷贝序列化
6
7// 使用压缩
8import "compress/gzip"

 1// ❌ N+1 查询
 2for _, user := range users {
 3    db.Query("SELECT * FROM orders WHERE user_id = ?", user.ID)
 4}
 5
 6// ✅ JOIN 或批量查询
 7db.Query(`
 8    SELECT u.*, o.* 
 9    FROM users u 
10    LEFT JOIN orders o ON u.id = o.user_id
11`)

1// 添加合适索引
2CREATE INDEX idx_user_email ON users(email);
3CREATE INDEX idx_order_user_date ON orders(user_id, created_at);

1db.SetMaxOpenConns(100)     // 最大连接数
2db.SetMaxIdleConns(25)      // 最大空闲连接数
3db.SetConnMaxLifetime(5 * time.Minute)  // 连接最大生命周期

1import _ "net/http/pprof"
2
3go func() {
4    http.ListenAndServe(":6060", nil)
5}()
6
7// 收集数据
8go tool pprof http://localhost:6060/debug/pprof/profile
9go tool pprof http://localhost:6060/debug/pprof/heap

1import "runtime/trace"
2
3trace.Start(w)
4defer trace.Stop(w)
5
6// 分析
7go tool trace trace.out

 1import "expvar"
 2
 3var (
 4    requestCount = expvar.NewInt("request_count")
 5    avgLatency   = expvar.NewFloat("avg_latency_ms")
 6)
 7
 8func handler(w http.ResponseWriter, r *http.Request) {
 9    start := time.Now()
10    // 处理请求
11    latency := time.Since(start).Milliseconds()
12    requestCount.Add(1)
13    // 更新平均延迟...
14}

1# 多阶段构建
2FROM golang:1.21 AS builder
3WORKDIR /app
4COPY . .
5RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
6
7FROM alpine:latest
8COPY --from=builder /app/app .
9CMD ["./app"]

1# 调整系统参数
2sysctl -w net.core.somaxconn=65535
3sysctl -w net.ipv4.tcp_tw_reuse=1
4sysctl -w net.ipv4.ip_local_port_range="1024 65000"

1import "runtime"
2
3// 设置 GOMAXPROCS
4runtime.GOMAXPROCS(runtime.NumCPU())
5
6// 使用 taskset 绑定 CPU
7// taskset -c 0-3 ./app

 1// 性能优化检查清单
 2□ 1. 是否有不必要的内存分配？
 3□ 2. 是否可以复用对象（sync.Pool）？
 4□ 3. 是否有锁竞争？
 5□ 4. 是否使用了合适的并发模式？
 6□ 5. 算法复杂度是否可以降低？
 7□ 6. 是否有重复计算？
 8□ 7. I/O 操作是否可以批量处理？
 9□ 8. 是否使用了缓冲 I/O？
10□ 9. 数据库查询是否有索引？
11□ 10. 是否启用了连接池？
12□ 11. 是否避免了不必要的 []byte/string 转换？
13□ 12. 是否使用了合适的序列化格式？
14□ 13. 是否监控了关键指标？