思考: 用户问的是北京天气，我需要调用天气API
行动: call weather_api(city="北京")
观察: 返回 {"temp": 25, "condition": "晴"}
思考: 已获取天气数据，可以回复用户
回答: 北京今天25°C，天气晴朗。

// LLM 输出
{
  "tool": "search_database",
  "arguments": {
    "query": "2024年Q3销售额",
    "table": "sales"
  }
}

// 系统执行工具，将结果注入下一轮对话

问：一个商店有 23 个苹果，卖了 17 个，又进了 12 个，现在有多少？
Let's think step by step:
1. 初始: 23 个
2. 卖出: 23 - 17 = 6 个
3. 进货: 6 + 12 = 18 个
答: 18 个

你是一个资深 Go 开发工程师。

## 角色
- 精通 Go 语言底层原理和最佳实践
- 善于代码审查和性能优化

## 约束
- 所有代码使用 Go 1.21+ 特性
- 遵循 Effective Go 规范
- 给出建议时附带原因

## 输出格式
- 代码块使用 Go 语法高亮
- 重要概念用**粗体**标注

type hmap struct {
    count     int    // 元素数量
    flags     uint8  // 状态标志(是否正在写入)
    B         uint8  // bucket 数量 = 2^B
    noverflow uint16 // 溢出桶数量
    hash0     uint32 // 哈希种子
    buckets    unsafe.Pointer // 桶数组
    oldbuckets unsafe.Pointer // 扩容时的旧桶
    nevacuate  uintptr        // 扩容进度
}

type bmap struct {
    tophash [8]uint8 // 每个 key 哈希值的高8位
    // 后面跟着 8个key 和 8个value（编译期计算布局）
    // 最后是 overflow 指针
}

type slice struct {
    array unsafe.Pointer // 底层数组指针
    len   int           // 当前长度
    cap   int           // 容量
}

// 扩容策略 (Go 1.18+)
// oldCap < 256: newCap = oldCap * 2
// oldCap >= 256: newCap = oldCap + oldCap/4 + 192 (约1.25倍增长)

// 危险：大切片的小引用会阻止 GC 回收整个底层数组
func getFirstThree(data []byte) []byte {
    return data[:3] // 底层数组不会被 GC
}

// 安全：复制所需数据
func getFirstThree(data []byte) []byte {
    result := make([]byte, 3)
    copy(result, data[:3])
    return result
}

type hchan struct {
    qcount   uint   // 队列中的数据数量
    dataqsiz uint   // 环形缓冲区大小
    buf      unsafe.Pointer // 环形缓冲区指针
    elemsize uint16 // 元素大小
    closed   uint32 // 是否已关闭
    sendx    uint   // 发送索引
    recvx    uint   // 接收索引
    recvq    waitq  // 等待接收的 goroutine 队列
    sendq    waitq  // 等待发送的 goroutine 队列
    lock     mutex  // 互斥锁
}

// 包含方法的 interface
type iface struct {
    tab  *itab          // 类型信息 + 方法表
    data unsafe.Pointer // 指向实际数据
}

// 空 interface
type eface struct {
    _type *_type         // 类型信息
    data  unsafe.Pointer // 指向实际数据
}

// nil interface 陷阱
var e error          // e == nil (iface 的 tab 和 data 都为 nil)
var p *MyError = nil
e = p                // e != nil! (iface 的 tab 不为 nil)

// 差的布局：占 24 字节
type Bad struct {
    a bool    // 1 + 7 padding
    b int64   // 8
    c bool    // 1 + 7 padding
}

// 好的布局：占 16 字节
type Good struct {
    b int64   // 8
    a bool    // 1
    c bool    // 1 + 6 padding
}
// 规则：按字段对齐大小降序排列

_Gidle → _Grunnable → _Grunning → _Gwaiting → _Grunnable → ...
                          ↓
                      _Gsyscall → _Grunnable
                          ↓
                       _Gdead

// 常见泄漏模式
func leak() {
    ch := make(chan int)
    go func() {
        val := <-ch // 永远阻塞，因为没人发送
        fmt.Println(val)
    }()
    // ch 没有 close，goroutine 永远不会退出
}

// 排查工具
// 1. runtime.NumGoroutine() 监控数量趋势
// 2. pprof goroutine profile
// 3. go tool pprof http://localhost:6060/debug/pprof/goroutine

// GOGC：控制 GC 触发频率
// GOGC=100 (默认)：堆内存翻倍时触发
// GOGC=200：堆增长到 3x 时触发（减少 GC 频率，增加内存占用）
// GOGC=50：堆增长到 1.5x 时触发（更频繁 GC，减少内存占用）

// Go 1.19+ GOMEMLIMIT：设置内存软上限
// GOMEMLIMIT=4GiB  →  GC 会更积极地在接近 4GB 时回收
// 配合 GOGC=off 使用：纯粹靠内存限制驱动 GC

// Ballast 技巧（Go 1.19 之前）
// 分配大块不用的内存，降低 GC 频率
var ballast = make([]byte, 1<<30) // 1GB ballast

// sync.Map 内部使用 read-only map + dirty map 双存储
// 适用于：读多写少、key 稳定不频繁增删
// 不适用于：写密集、需要遍历、需要 Len()

// 读操作流程：
// 1. 先查 read map（无锁 atomic）→ 命中直接返回
// 2. miss → 加锁查 dirty map → 提升 dirty 为 read

// 替代方案：分片锁 map
type ShardedMap struct {
    shards [256]struct {
        sync.RWMutex
        m map[string]interface{}
    }
}
func (s *ShardedMap) getShard(key string) int {
    h := fnv.New32a()
    h.Write([]byte(key))
    return int(h.Sum32()) & 255
}

// 1. 超时控制
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()

// 2. 取消传播
func worker(ctx context.Context) error {
    select {
    case <-ctx.Done():
        return ctx.Err() // context.Canceled 或 context.DeadlineExceeded
    case result := <-doWork():
        return process(result)
    }
}

// 3. 不要在 struct 中存储 context（应作为函数第一个参数）
// 4. 不要传递 nil context，用 context.TODO()
// 5. context.Value 仅用于请求级元数据（trace-id），不用于业务参数

import "golang.org/x/sync/errgroup"

g, ctx := errgroup.WithContext(context.Background())
g.SetLimit(10) // 限制并发数

for _, url := range urls {
    url := url
    g.Go(func() error {
        return fetch(ctx, url)
    })
}

if err := g.Wait(); err != nil {
    // 任一 goroutine 返回 error，ctx 被取消
    log.Fatal(err)
}

import _ "net/http/pprof"

func main() {
    go func() {
        http.ListenAndServe(":6060", nil)
    }()
    // ...
}

// 命令行分析
// go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30  # CPU
// go tool pprof http://localhost:6060/debug/pprof/heap                # 内存
// go tool pprof http://localhost:6060/debug/pprof/goroutine           # goroutine

// go build -gcflags="-m" main.go

// 逃逸到堆的常见场景：
// 1. 返回局部变量的指针
func newUser() *User { return &User{} } // escapes to heap

// 2. 闭包引用外部变量
func closure() func() int {
    x := 0
    return func() int { x++; return x } // x escapes
}

// 3. interface 参数（编译器无法确定大小）
fmt.Println(x) // x escapes (参数是 interface{})

func BenchmarkConcat(b *testing.B) {
    b.Run("Plus", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            s := ""
            for j := 0; j < 100; j++ {
                s += "hello"
            }
        }
    })
    b.Run("Builder", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            var sb strings.Builder
            for j := 0; j < 100; j++ {
                sb.WriteString("hello")
            }
            _ = sb.String()
        }
    })
}
// go test -bench=. -benchmem

-- 联合索引 (name, age)
-- 覆盖索引：查询的字段都在索引中，无需回表
SELECT name, age FROM users WHERE name = '张三'; -- Using index

-- 需要回表：email 不在索引中
SELECT name, age, email FROM users WHERE name = '张三';

ReadView 包含：
- m_ids: 创建 ReadView 时活跃（未提交）的事务 ID 列表
- min_trx_id: m_ids 中最小的事务 ID
- max_trx_id: 下一个将分配的事务 ID
- creator_trx_id: 创建该 ReadView 的事务 ID

可见性判断：
1. trx_id == creator_trx_id → 可见（自己修改的）
2. trx_id < min_trx_id → 可见（事务已提交）
3. trx_id >= max_trx_id → 不可见（ReadView 之后才开始的事务）
4. min_trx_id <= trx_id < max_trx_id:
   - trx_id 在 m_ids 中 → 不可见（事务未提交）
   - trx_id 不在 m_ids 中 → 可见（事务已提交）

-- 表结构：id(PK), age(普通索引), name
-- 数据：(1,10,'A'), (5,20,'B'), (10,30,'C'), (15,40,'D')

-- Case 1: 主键等值查询（存在）
SELECT * FROM t WHERE id = 5 FOR UPDATE;
-- 加锁：Record Lock on id=5

-- Case 2: 主键等值查询（不存在）
SELECT * FROM t WHERE id = 7 FOR UPDATE;
-- 加锁：Gap Lock on (5, 10)

-- Case 3: 普通索引等值查询
SELECT * FROM t WHERE age = 20 FOR UPDATE;
-- 加锁：Next-Key Lock on age (10,20] + Gap Lock (20,30)
--        + Record Lock on 主键 id=5

-- Case 4: 普通索引范围查询
SELECT * FROM t WHERE age >= 20 AND age < 40 FOR UPDATE;
-- 加锁：Next-Key Lock on age (10,20], (20,30], (30,40)

-- 慢：深分页，需要扫描 10000+10 行
SELECT * FROM orders ORDER BY id LIMIT 10000, 10;

-- 优化1：延迟关联
SELECT o.* FROM orders o
INNER JOIN (SELECT id FROM orders ORDER BY id LIMIT 10000, 10) t
ON o.id = t.id;

-- 优化2：游标分页（需要上一页最后一条的 id）
SELECT * FROM orders WHERE id > 10000 ORDER BY id LIMIT 10;

struct sdshdr {
    int len;    // 已使用长度
    int free;   // 剩余可用空间
    char buf[]; // 字节数组
};
// 优点：O(1)获取长度、二进制安全、空间预分配减少realloc、惰性释放

// 加锁
SET lock_key unique_value NX EX 30

// 解锁（Lua 脚本保证原子性）
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

ZADD rank 100 user:1
ZADD rank 200 user:2
ZREVRANGE rank 0 9 WITHSCORES  # Top 10
ZRANK rank user:1              # 查排名

// 用 ZSet 实现滑动窗口限流
func isAllowed(userID string, limit int, window time.Duration) bool {
    key := "ratelimit:" + userID
    now := time.Now().UnixMilli()
    pipe := rdb.Pipeline()
    pipe.ZRemRangeByScore(ctx, key, "0", strconv.FormatInt(now-window.Milliseconds(), 10))
    pipe.ZCard(ctx, key)
    pipe.ZAdd(ctx, key, redis.Z{Score: float64(now), Member: now})
    pipe.Expire(ctx, key, window)
    results, _ := pipe.Exec(ctx)
    count := results[1].(*redis.IntCmd).Val()
    return count < int64(limit)
}

// Redis Lua 脚本原子扣减
local stock = tonumber(redis.call('get', KEYS[1]))
if stock <= 0 then
    return -1  -- 已售罄
end
redis.call('decr', KEYS[1])
return stock - 1

// 流程：
// 1. Redis 预扣库存（Lua 原子操作）
// 2. 扣减成功 → 发送 MQ 消息（订单创建）
// 3. 消费者异步落库（数据库扣减 + 创建订单）
// 4. 失败回滚：定时任务检查未支付订单，回补库存

| 1 bit 符号位 | 41 bit 时间戳 | 10 bit 机器ID | 12 bit 序列号 |
                 (69年)          (1024台)         (4096/ms)

// 单机每毫秒生成 4096 个不重复 ID
// 时钟回拨问题：拒绝生成 / 等待 / 备用ID段

Client              Server
  |--- SYN(seq=x) --->|     Client: SYN_SENT
  |<-- SYN+ACK(seq=y, ack=x+1) ---|  Server: SYN_RCVD
  |--- ACK(ack=y+1) -->|    Client: ESTABLISHED
                             Server: ESTABLISHED

为什么三次？
- 两次不行：Server 无法确认 Client 收到了 SYN+ACK（可能建立已失效的连接）
- 四次多余：第三次已足够双方确认收发能力

Client              Server
  |--- FIN --->|    Client: FIN_WAIT_1
  |<-- ACK ----|    Client: FIN_WAIT_2, Server: CLOSE_WAIT
  |<-- FIN ----|    Server: LAST_ACK
  |--- ACK --->|    Client: TIME_WAIT (等待 2MSL)
                    Server: CLOSED

TIME_WAIT 为什么等 2MSL（60s）？
1. 确保最后一个 ACK 能到达 Server（如果丢了，Server 会重发 FIN）
2. 让本次连接的残余报文在网络中消失

// 升级请求
GET /chat HTTP/1.1
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==

// 响应
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

# 多阶段构建
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download          # 利用缓存层
COPY . .
RUN CGO_ENABLED=0 go build -o server .

FROM alpine:3.19
RUN apk add --no-cache ca-certificates tzdata
COPY --from=builder /app/server /server
EXPOSE 8080
ENTRYPOINT ["/server"]

# 最终镜像仅包含二进制和运行时依赖，约 20MB

apiVersion: apps/v1
kind: Deployment
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # 最多多创建1个Pod
      maxUnavailable: 0  # 不允许有不可用Pod
  template:
    spec:
      containers:
      - name: app
        image: myapp:v2
        readinessProbe:   # 就绪检查，通过才接收流量
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

// 求最大的 K 个元素 → 维护大小为 K 的最小堆
// 时间复杂度: O(n log K)
type MinHeap []int
func (h MinHeap) Len() int           { return len(h) }
func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *MinHeap) Push(x any)        { *h = append(*h, x.(int)) }
func (h *MinHeap) Pop() any {
    old := *h; n := len(old)
    x := old[n-1]; *h = old[:n-1]
    return x
}

// 无重复字符的最长子串 (LeetCode 3)
func lengthOfLongestSubstring(s string) int {
    window := make(map[byte]int)
    left, result := 0, 0
    for right := 0; right < len(s); right++ {
        c := s[right]
        window[c]++
        for window[c] > 1 {
            window[s[left]]--
            left++
        }
        if right-left+1 > result {
            result = right - left + 1
        }
    }
    return result
}

// 查找左边界
func searchLeft(nums []int, target int) int {
    lo, hi := 0, len(nums)
    for lo < hi {
        mid := lo + (hi-lo)/2
        if nums[mid] < target {
            lo = mid + 1
        } else {
            hi = mid
        }
    }
    return lo // 第一个 >= target 的位置
}