阶段2(上):后端专题 Go/Gin/PostgreSQL/MySQL/Redis/MQ/gRPC 的课程、企业场景、面试题和可运行示例

This commit is contained in:
Shikui Wang committed 2026-10-23 15:24:57 +08:00
1 parent 0bae9916a9
commit 5eb67c5d08
65 files changed
+6457 -77

No files matched your search

+117
View File
@@ -0,0 +1,117 @@
---
id: backend.go.basics-types
title: 语法、类型和接口(对照 TypeScript)
type: lesson
domain: backend
stack: [go]
tags: [Go, 切片, map, 结构体, 接口]
level: basic
est_hours: 4
related: [backend.go.interview]
week: [1]
order: 1
---
# 语法、类型和接口(对照 TypeScript)
## 解释说明
Go 是静态类型、编译型语言,语法关键字只有 25 个。对前端开发者来说,最需要转变的几点:
| 概念 | TypeScript | Go |
| --- | --- | --- |
| 变量 | `let x = 1` | `x := 1`(函数内)或 `var x int = 1` |
| 数组 / 列表 | `number[]` | 切片 `[]int`:底层是“指向数组的指针 + 长度 + 容量” |
| 对象 / 字典 | `Record<string, number>` | `map[string]int`,**使用前必须初始化** |
| 类 / 接口 | `class`、`interface` 需要 `implements` | 结构体 + 方法;接口是**隐式实现**:方法对得上就算实现 |
| 空值 | `null` / `undefined` | 每种类型都有“零值”:`0`、`""`、`false`、`nil` |
| 异常 | `throw` / `try` | 函数多返回值,最后一个是 `error`,调用方显式检查 |
| 可见性 | `export` | 名字**首字母大写**就是导出的 |
- **切片**:`append` 超过容量时会分配新的底层数组,所以 `append` 的结果一定要接住:`s = append(s, x)`。两个切片可能共享同一个底层数组,修改一个会影响另一个。
- **指针**:Go 的函数参数都是值拷贝。要在方法里修改结构体,用**指针接收者** `func (t *Task) Done()`。
- **接口**:小接口是 Go 的习惯,例如标准库的 `io.Reader` 只有一个方法。依赖接口而不是具体类型,测试时就能换成假实现。
## 案例
企业后端最常见的分层:`handler`(HTTP)→ `service`(业务)→ `store`(数据库)。`store` 定义成接口,生产用 PostgreSQL 实现,单元测试用内存实现——第 1 周的 `todo-api` 就是这样做的。
## 代码示例
```go
package main
import (
"errors"
"fmt"
"sort"
)
type Task struct {
ID int
Title string
Done bool
}
// 指针接收者:修改的是原对象
func (t *Task) Finish() { t.Done = true }
// TaskStore 是一个小接口:任何有这两个方法的类型都自动实现它
type TaskStore interface {
Add(title string) (Task, error)
List() []Task
}
type MemoryStore struct {
nextID int
tasks map[int]Task
}
func NewMemoryStore() *MemoryStore { return &MemoryStore{nextID: 1, tasks: map[int]Task{}} }
var ErrEmptyTitle = errors.New("标题不能为空")
func (m *MemoryStore) Add(title string) (Task, error) {
if title == "" {
return Task{}, ErrEmptyTitle
}
t := Task{ID: m.nextID, Title: title}
m.tasks[t.ID] = t
m.nextID++
return t, nil
}
func (m *MemoryStore) List() []Task {
out := make([]Task, 0, len(m.tasks)) // 预分配容量
for _, t := range m.tasks {
out = append(out, t)
}
sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID }) // map 遍历顺序是随机的
return out
}
func main() {
var store TaskStore = NewMemoryStore() // 编译期检查 *MemoryStore 实现了接口
_, _ = store.Add("学 Go")
if _, err := store.Add(""); errors.Is(err, ErrEmptyTitle) {
fmt.Println("校验生效:", err)
}
tasks := store.List()
tasks[0].Finish()
fmt.Printf("%+v\n", tasks)
}
```
运行:保存为 `main.go`,执行 `go run main.go`。
## 易错点
- **map 没初始化就写入**:`var m map[string]int; m["a"] = 1` 会 panic。用 `make` 或字面量 `map[string]int{}` 初始化。
- **map 遍历顺序随机**:需要稳定顺序时先取出 key 排序。
- **切片共享底层数组**:`b := a[:2]; b[0] = 9` 会改到 `a`;需要独立副本时用 `copy` 或 `slices.Clone`。
- **值接收者改不了原对象**:方法要修改字段就用指针接收者;同一个类型的方法接收者风格保持一致。
- **接口里的 nil**:把一个值为 `nil` 的指针赋给接口,接口本身不等于 `nil`(类型信息还在),返回错误时要直接 `return nil`。
## 面试常问
见 [Go 面试题](interview.md) 中的切片扩容、接口隐式实现、值接收者和指针接收者。
+123
View File
@@ -0,0 +1,123 @@
---
id: backend.go.errors-concurrency
title: 错误处理和并发:goroutine、channel、context
type: lesson
domain: backend
stack: [go]
tags: [Go, 错误处理, goroutine, channel, context, 并发]
level: intermediate
prerequisites: [backend.go.basics-types]
est_hours: 4
related: [backend.go.scenario.batch-third-party-calls, backend.go.interview]
week: [1, 3]
order: 2
---
# 错误处理和并发:goroutine、channel、context
## 解释说明
**错误处理**
- 错误是普通的值。用 `fmt.Errorf("读取配置: %w", err)` **包装**错误,保留原始错误并加上下文;调用方用 `errors.Is(err, ErrNotFound)` 判断是不是某个错误,用 `errors.As(err, &target)` 取出某种类型的错误。
- 只在真正不可恢复的情况下用 `panic`(例如程序启动时配置缺失);HTTP 服务里用中间件 `recover`,防止一个请求的 panic 让整个进程退出。
**并发**
- **goroutine**:`go f()` 启动一个轻量级“线程”(初始栈几 KB,由 Go 运行时调度到系统线程上),可以轻松开成千上万个。
- **channel**:goroutine 之间传递数据的管道。无缓冲 channel 收发双方要同时就绪;有缓冲 channel 满了才阻塞发送。“不要通过共享内存来通信,而要通过通信来共享内存。”
- **select**:同时等待多个 channel,哪个先就绪处理哪个;常用来实现超时和取消。
- **sync**:`WaitGroup` 等待一组 goroutine 结束;`Mutex` / `RWMutex` 保护共享数据;`Once` 只执行一次。
- **context**:在调用链上传递**取消信号、超时和请求范围的值**。HTTP 请求进来时创建,往下传给数据库查询、外部调用;客户端断开或超时,下游全部及时停止。约定:`ctx` 作为函数的第一个参数。
## 案例
- 一个接口要同时查用户信息、订单列表、优惠券三个下游服务:三个 goroutine 并发查询,整体用 `context.WithTimeout` 限制 2 秒,任一失败就取消其他的(`errgroup` 的典型用法)。
- 消息消费者:从队列取消息、交给固定数量的 worker 处理(worker pool),服务关闭时通过 `context` 通知 worker 处理完手上的消息再退出。
## 代码示例
一个带超时和取消的 worker pool:
```go
package main
import (
"context"
"errors"
"fmt"
"sync"
"time"
)
var ErrInvalid = errors.New("无效的任务")
func process(ctx context.Context, n int) (int, error) {
if n < 0 {
return 0, fmt.Errorf("处理 %d: %w", n, ErrInvalid) // 包装错误
}
select {
case <-time.After(time.Duration(n) * 10 * time.Millisecond): // 模拟耗时操作
return n * n, nil
case <-ctx.Done(): // 超时或被取消
return 0, ctx.Err()
}
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 150*time.Millisecond)
defer cancel()
jobs := make(chan int)
type result struct {
n, v int
err error
}
results := make(chan result)
var wg sync.WaitGroup
for w := 0; w < 3; w++ { // 3 个 worker
wg.Add(1)
go func() {
defer wg.Done()
for n := range jobs { // jobs 关闭后循环结束
v, err := process(ctx, n)
results <- result{n, v, err}
}
}()
}
go func() {
for _, n := range []int{1, 2, -1, 3, 50} {
jobs <- n
}
close(jobs) // 发送方负责关闭
}()
go func() { wg.Wait(); close(results) }() // 全部 worker 结束后关闭结果通道
for r := range results {
switch {
case errors.Is(r.err, ErrInvalid):
fmt.Println(r.n, "参数错误:", r.err)
case errors.Is(r.err, context.DeadlineExceeded):
fmt.Println(r.n, "超时")
default:
fmt.Println(r.n, "=>", r.v)
}
}
}
```
运行:`go run main.go`,再用 `go run -race main.go` 检查数据竞争。完整的生产写法(并发上限、单次超时、部分失败)见 [examples/batch-fetch](examples/batch-fetch/)。
## 易错点
- **goroutine 泄漏**:goroutine 阻塞在没人接收的 channel 上永远不退出。每个 goroutine 都要想清楚“它什么时候结束”,配合 `context` 或关闭 channel。
- **向已关闭的 channel 发送会 panic**;关闭的责任在发送方,多个发送方时用 `WaitGroup` 等全部结束再关闭。
- **循环变量**:Go 1.22 起每次循环都是新变量,旧版本里在 goroutine 中直接用循环变量会全部拿到最后一个值。
- **map 不是并发安全的**:多个 goroutine 同时读写会直接崩溃(fatal error),用 `Mutex` 或 `sync.Map`。
- **把 context 存进结构体**:context 应该随调用传递,不要长期保存。
- **吞掉错误**:`_ = f()` 要有理由;记录日志和返回错误二选一,不要两个都做(会重复打印)。
## 面试常问
见 [Go 面试题](interview.md):GMP 调度、channel 的阻塞规则、context 的用途、如何发现数据竞争。
+100
View File
@@ -0,0 +1,100 @@
---
id: backend.go.testing-engineering
title: 测试和工程化:表格驱动测试、httptest、模块、项目结构
type: lesson
domain: backend
stack: [go]
tags: [Go, 测试, httptest, go mod, 项目结构]
level: intermediate
prerequisites: [backend.go.basics-types]
est_hours: 3
related: [backend.go.interview, backend.gin.routing-binding]
week: [1, 2, 3]
order: 3
---
# 测试和工程化:表格驱动测试、httptest、模块、项目结构
## 解释说明
- **go test**:`xxx_test.go` 里的 `TestXxx(t *testing.T)` 会被自动执行。`t.Run` 定义子测试;`-race` 检测数据竞争;`-cover` 看覆盖率;`BenchmarkXxx` 做性能测试。
- **表格驱动测试**:把多组“输入 + 期望”写成切片循环执行,是 Go 社区的惯例,新增用例只加一行。
- **httptest**:`httptest.NewRecorder()` 不启动端口直接测 handler;`httptest.NewServer` 启动一个真实的本地服务,用来模拟第三方接口。
- **模块**:`go mod init 模块名` 生成 `go.mod`;`go get` 加依赖;`go mod tidy` 清理。`go.sum` 记录依赖的校验和,要提交。
- **项目结构**(社区常见做法,不是强制标准):`cmd/<程序名>/main.go` 放入口;`internal/` 放不希望被其他模块导入的代码(编译器强制);按职责分包(`handler`、`service`、`store`),避免一个 `utils` 包装所有东西。
## 案例
接口层的测试一般这样分:handler 测试用 `httptest.NewRecorder` + 内存版 store,覆盖参数校验、状态码、鉴权;store 的集成测试连真实数据库(没有数据库时跳过);调用第三方的代码用 `httptest.NewServer` 模拟各种返回(超时、500、格式错误)。
## 代码示例
```go
// 文件:slug.go
package slug
import (
"strings"
"unicode"
)
// Make 把标题转成 URL 片段:小写、空白和标点变成 -,去掉首尾 -
func Make(title string) string {
var b strings.Builder
dash := false
for _, r := range strings.ToLower(title) {
if unicode.IsLetter(r) || unicode.IsDigit(r) {
b.WriteRune(r)
dash = false
} else if !dash && b.Len() > 0 {
b.WriteByte('-')
dash = true
}
}
return strings.TrimSuffix(b.String(), "-")
}
```
```go
// 文件:slug_test.go
package slug
import "testing"
func TestMake(t *testing.T) {
cases := []struct {
name, in, want string
}{
{"普通", "Hello World", "hello-world"},
{"多个符号", "Go -- 并发!!", "go-并发"},
{"首尾空白", " Redis ", "redis"},
{"空", "", ""},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
if got := Make(c.in); got != c.want {
t.Fatalf("Make(%q) = %q, want %q", c.in, got, c.want)
}
})
}
}
func BenchmarkMake(b *testing.B) {
for b.Loop() { // Go 1.24+ 的写法;旧版本用 for i := 0; i < b.N; i++
Make("Hello World From Go")
}
}
```
运行:`go mod init slug && go test -v -race -cover ./... && go test -bench=. ./...`
## 易错点
- 测试之间共享全局状态(全局 map、同一张表)会让测试结果依赖执行顺序;每个测试自己准备数据,`t.Cleanup` 清理。
- 只测“正常路径”:错误路径(参数错、下游失败、超时)才是线上出问题的地方。
- `internal` 包只能被它的父目录及子目录导入;别的模块导入会编译失败——这是故意的。
- 不提交 `go.sum` 会让别人构建时无法校验依赖。
## 面试常问
见 [Go 面试题](interview.md):怎么测试依赖数据库或第三方接口的代码、`internal` 的作用。
@@ -0,0 +1,64 @@
// Package batchfetch 演示企业里常见的“批量调用第三方接口”:
// 并发上限、单次超时、整体取消、部分失败不影响其他结果、结果顺序与输入一致。
package batchfetch
import (
"context"
"fmt"
"io"
"net/http"
"net/url"
"sync"
"time"
)
type Result struct {
ID string
Body string
Err error
}
// FetchAll 最多同时发出 limit 个请求,每个请求最多等待 perReq。
func FetchAll(ctx context.Context, client *http.Client, baseURL string, ids []string, limit int, perReq time.Duration) []Result {
results := make([]Result, len(ids)) // 每个 goroutine 只写自己的下标,不需要加锁
sem := make(chan struct{}, limit) // 信号量:缓冲区大小就是并发上限
var wg sync.WaitGroup
for i, id := range ids {
wg.Add(1)
go func() {
defer wg.Done()
select {
case sem <- struct{}{}: // 拿到名额
case <-ctx.Done(): // 整体已取消,不再发请求
results[i] = Result{ID: id, Err: ctx.Err()}
return
}
defer func() { <-sem }()
results[i] = fetchOne(ctx, client, baseURL, id, perReq)
}()
}
wg.Wait()
return results
}
func fetchOne(ctx context.Context, client *http.Client, baseURL, id string, timeout time.Duration) Result {
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/items/"+url.PathEscape(id), nil)
if err != nil {
return Result{ID: id, Err: err}
}
resp, err := client.Do(req)
if err != nil {
return Result{ID: id, Err: fmt.Errorf("请求 %s: %w", id, err)}
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return Result{ID: id, Err: fmt.Errorf("请求 %s: 状态码 %d", id, resp.StatusCode)}
}
body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) // 限制响应大小,防止对方返回超大内容
if err != nil {
return Result{ID: id, Err: fmt.Errorf("读取 %s: %w", id, err)}
}
return Result{ID: id, Body: string(body)}
}
@@ -0,0 +1,78 @@
package batchfetch
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
)
func TestFetchAll(t *testing.T) {
var cur, peak int64
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
n := atomic.AddInt64(&cur, 1)
defer atomic.AddInt64(&cur, -1)
for {
p := atomic.LoadInt64(&peak)
if n <= p || atomic.CompareAndSwapInt64(&peak, p, n) {
break
}
}
id := strings.TrimPrefix(r.URL.Path, "/items/")
switch id {
case "slow":
select {
case <-time.After(time.Second):
case <-r.Context().Done():
}
case "bad":
http.Error(w, "boom", http.StatusInternalServerError)
return
default:
time.Sleep(20 * time.Millisecond)
}
_, _ = w.Write([]byte("ok:" + id))
}))
defer srv.Close()
ids := []string{"a", "b", "slow", "c", "bad", "d", "e", "f"}
res := FetchAll(context.Background(), srv.Client(), srv.URL, ids, 3, 200*time.Millisecond)
if peak > 3 {
t.Fatalf("并发数 %d 超过上限 3", peak)
}
for i, r := range res {
if r.ID != ids[i] {
t.Fatalf("结果顺序不对:%v", r.ID)
}
switch r.ID {
case "slow":
if !errors.Is(r.Err, context.DeadlineExceeded) {
t.Fatalf("slow 应该超时,得到 %v", r.Err)
}
case "bad":
if r.Err == nil || !strings.Contains(r.Err.Error(), "500") {
t.Fatalf("bad 应该返回 500 错误,得到 %v", r.Err)
}
default:
if r.Err != nil || r.Body != "ok:"+r.ID {
t.Fatalf("%s: %v %q", r.ID, r.Err, r.Body)
}
}
}
}
func TestCancelledContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
res := FetchAll(ctx, http.DefaultClient, "http://127.0.0.1:1", []string{"x", "y"}, 1, time.Second)
for _, r := range res {
if r.Err == nil {
t.Fatal("已取消的 context 应该让所有请求失败")
}
}
}
@@ -0,0 +1,3 @@
module example/batchfetch
go 1.22
+29 -3
View File
@@ -4,12 +4,38 @@ title: Go 语言
type: index
domain: backend
stack: [go]
tags: []
tags: [Go, 后端, 并发]
week: [1, 2, 3, 14]
---
# Go 语言
语法、接口、错误处理、并发、测试和工程化。
Go 在本计划里是**加分项**:目标是能独立写出带数据库、鉴权、缓存、部署的后端服务,并能回答常见的 Go 面试题。语法简单、并发好用、部署是一个二进制文件——这些是企业选 Go 的主要原因。
> 本专题建设中:课程、企业场景、面试题和示例代码会陆续补充。
## 学习路线
| 顺序 | 课程 | 级别 | 预计 |
| --- | --- | --- | --- |
| 1 | [语法、类型和接口(对照 TypeScript)](01-basics-types.md) | 基础 | 4 小时 |
| 2 | [错误处理和并发:goroutine、channel、context](02-errors-concurrency.md) | 进阶 | 4 小时 |
| 3 | [测试和工程化:表格驱动测试、httptest、模块、项目结构](03-testing-engineering.md) | 进阶 | 3 小时 |
## 企业场景
- [批量调用第三方接口:并发控制、超时和部分失败](scenarios/batch-third-party-calls.md)
## 面试题
- [Go 面试题(基础 / 进阶 / 场景题)](interview.md)
## 示例代码
- [examples/batch-fetch](examples/batch-fetch/):有并发上限、单次超时、部分失败的批量请求(`go test ./...`)
## 在 16 周计划中
- [第 1 周:Go 基础 + Gin](../../../plan/week01-go-gin.md)、[第 2 周:数据库 + 鉴权](../../../plan/week02-db-auth.md)、[第 3 周:项目一](../../../plan/week03-project1.md)、[第 14 周:可选 Go 网关](../../../plan/week14-backend-extend-deploy.md)
## 官方资料
- Go 官方教程(中文):https://tour.go-zh.org/ ;Effective Go:https://go.dev/doc/effective_go ;Go by Example(中文):https://gobyexample-cn.github.io/
+85
View File
@@ -0,0 +1,85 @@
---
id: backend.go.interview
title: Go 面试题
type: interview
domain: backend
stack: [go]
tags: [Go, 面试]
level: intermediate
related: [backend.go.basics-types, backend.go.errors-concurrency, backend.go.testing-engineering]
week: [1, 3, 16]
---
# Go 面试题
> 在本计划里的体现:`todo-api`、`task-board`(第 1~3 周),可选的 Go 网关(第 14 周)。
## 基础
### 【基础】切片(slice)和数组有什么区别?append 什么时候扩容?
**参考答案**:数组长度固定,是值类型,赋值会整体拷贝;切片是对底层数组的引用,包含指针、长度(len)和容量(cap)。`append` 时如果容量够就直接写入底层数组,不够就分配一个更大的新数组并拷贝(小切片大约翻倍,大切片按更小的比例增长,具体策略随版本调整)。所以 `append` 的返回值必须接住。
**追问**:两个切片共享底层数组会有什么问题?→ 修改一个会影响另一个;需要独立副本时用 `copy` 或 `slices.Clone`。
### 【基础】Go 的接口有什么特点?
**参考答案**:隐式实现——类型只要有接口要求的全部方法,就自动实现了这个接口,不需要声明 `implements`。好处是解耦:使用方定义小接口,实现方不需要知道这个接口的存在。常见做法是“接受接口,返回具体类型”。
**追问**:空接口 `any` 是什么?→ 没有方法的接口,所有类型都实现它;取出具体值要用类型断言 `v.(T)` 或类型 switch。
### 【基础】值接收者和指针接收者怎么选?
**参考答案**:需要修改接收者、或者结构体很大(避免拷贝)时用指针接收者;小的、不可变的值类型可以用值接收者。同一个类型的方法风格保持一致。注意:指针接收者的方法只属于 `*T` 的方法集,所以只有 `*T` 实现了相关接口。
### 【基础】Go 为什么没有异常?错误怎么处理?
**参考答案**:Go 把错误当成普通返回值,强制调用方显式处理,控制流清楚。用 `fmt.Errorf("...: %w", err)` 包装错误加上下文,用 `errors.Is` / `errors.As` 判断。`panic` 只用于不可恢复的错误,HTTP 服务用中间件 `recover` 兜底。
**追问**:`errors.Is` 和 `==` 的区别?→ `errors.Is` 会沿着包装链逐层比较,`==` 只比较最外层。
### 【基础】`defer` 的执行顺序和常见用途?
**参考答案**:函数返回前执行,多个 `defer` 后进先出。常用于关闭文件、释放锁、`recover`、记录耗时。参数在 `defer` 语句执行时就求值了。
**追问**:在循环里 `defer` 关闭文件有什么问题?→ 要等整个函数结束才关闭,循环次数多会耗尽文件句柄;把循环体提取成函数。
## 进阶
### 【进阶】goroutine 和线程有什么区别?讲讲 GMP 调度。
**参考答案**:goroutine 是 Go 运行时管理的轻量级协程,初始栈只有几 KB 且可增长,创建和切换成本远低于系统线程。GMP:G 是 goroutine,M 是系统线程,P 是调度用的处理器(数量默认等于 CPU 核数,`GOMAXPROCS`)。每个 P 有本地队列,M 绑定 P 执行其中的 G;队列空了会从全局队列或其他 P“偷”任务;G 阻塞在系统调用时,P 会交给其他 M 继续运行。
**追问**:goroutine 会不会被抢占?→ Go 1.14 起支持基于信号的异步抢占,长时间运行的循环也能被调度出去。
### 【进阶】channel 的阻塞规则?关闭后会怎样?
**参考答案**:无缓冲 channel 发送和接收必须同时就绪;有缓冲的满了发送阻塞、空了接收阻塞。关闭后:接收会先读完剩余数据,然后立即返回零值(`v, ok := <-ch` 中 `ok` 为 false);向已关闭的 channel 发送会 panic;重复关闭也会 panic;对 nil channel 收发永远阻塞。
**追问**:谁负责关闭 channel?→ 发送方;多个发送方时用 `WaitGroup` 等全部结束后由一个协调者关闭。
### 【进阶】context 有什么用?使用规范是什么?
**参考答案**:在调用链上传递取消信号、截止时间和请求范围的值。HTTP 请求结束或超时,所有带这个 context 的数据库查询、下游调用都会及时停止,避免资源浪费。规范:作为第一个参数传递、不要存进结构体、不要传 nil(用 `context.TODO()`)、`WithValue` 只放请求范围的元数据(如请求 ID),不放业务参数。
### 【进阶】什么是数据竞争?怎么发现和避免?
**参考答案**:多个 goroutine 同时访问同一变量且至少一个是写,又没有同步。用 `go test -race` / `go run -race` 发现(只能发现实际执行到的路径)。避免:用 channel 传递所有权、`sync.Mutex` / `RWMutex` 加锁、`sync/atomic` 原子操作;并发读写 map 会直接 fatal。
## 场景题
### 【场景题】一个接口要并发调用 3 个下游服务,整体 2 秒超时,任一失败就返回错误,怎么写?
**参考答案**:用 `errgroup.WithContext(ctx)` 配合 `context.WithTimeout(ctx, 2*time.Second)`:每个下游一个 `g.Go(...)`,任一返回错误时 errgroup 会取消共享的 context,其他调用随之停止;`g.Wait()` 返回第一个错误。下游客户端必须使用这个 context 才能真正被取消。如果需要“部分失败也返回”,就不用 errgroup 的取消语义,改成各自记录结果(见本技术栈的场景文档)。
**追问**:下游有一个特别慢但不重要的服务怎么办?→ 给它单独更短的超时,失败时降级(返回默认值)。
### 【场景题】线上 Go 服务内存持续上涨,怎么排查?
**参考答案**:先确认是不是泄漏:看监控的内存曲线和 goroutine 数量。用 `net/http/pprof` 暴露分析接口,抓 `heap` 看哪些对象占内存、抓 `goroutine` 看有没有大量阻塞在同一处的 goroutine(最常见的是 channel 没人接收、没设超时的网络请求)。对比两个时间点的 heap 差异定位增长来源。修复后加上超时和 context 取消。
**追问**:pprof 能直接暴露在公网吗?→ 不能,只在内网或通过鉴权访问。
### 【场景题】服务发布时如何做到不丢请求?
**参考答案**:优雅关机:监听 SIGTERM,调用 `http.Server.Shutdown(ctx)` 停止接收新连接并等待处理中的请求完成(带超时);后台 worker 通过 context 收到取消信号,处理完当前任务再退出;最后关闭数据库连接池。部署侧配合负载均衡的健康检查,先摘流量再停进程。在本计划第 1 周第 7 天实现过。
@@ -0,0 +1,98 @@
---
id: backend.go.scenario.batch-third-party-calls
title: 批量调用第三方接口:并发控制、超时和部分失败
type: scenario
domain: backend
stack: [go]
tags: [并发, 超时, 第三方接口, 限流, 重试]
level: intermediate
prerequisites: [backend.go.errors-concurrency]
est_hours: 2
related: [backend.go.interview, backend.redis.lock-ratelimit]
week: [3]
---
# 批量调用第三方接口:并发控制、超时和部分失败
## 业务背景与问题
电商后台的“批量查询物流状态”功能:运营一次选中几百个订单,系统要调用物流公司的查询接口,汇总后展示。第一版代码在一个循环里逐个调用,500 个订单要等一分多钟,接口经常超时;改成“每个订单开一个 goroutine”后又被物流公司限流(返回 429),偶尔还把自己服务的连接数打满。
## 约束
- 第三方接口限流:每个账号最多 10 个并发、每秒 50 次(以对方文档为准)。
- 单次调用一般 100~300 毫秒,偶尔卡住几十秒。
- 页面请求整体最多等 5 秒;部分订单查询失败不能让整批失败。
- 结果要和输入订单一一对应,方便前端展示。
## 方案设计
```mermaid
flowchart LR
A[接口收到订单列表] --> B{整体 context<br/>超时 5 秒}
B --> C[信号量:最多 10 个并发]
C --> D[单次请求 context<br/>超时 1 秒]
D -->|成功| E[写入结果下标 i]
D -->|失败 / 超时| F[记录该订单的错误]
E --> G[等待全部完成]
F --> G
G --> H[返回:成功列表 + 失败列表]
```
1. **并发上限**:用带缓冲的 channel 做信号量,缓冲大小 = 对方允许的并发数。
2. **两层超时**:整体 context 控制页面等待时间;单次请求再套一层短超时,避免一个慢请求占着名额。
3. **部分失败**:每个订单的结果独立记录错误,最后返回“成功 + 失败(带原因)”,前端可以对失败的单独重试。
4. **结果顺序**:预先分配结果切片,每个 goroutine 写自己的下标,不需要加锁。
5. **进一步**:每秒次数限制用令牌桶(`golang.org/x/time/rate`);多实例部署时用 Redis 做全局限流;常用订单的物流状态缓存 1~5 分钟;数量很大时改成异步任务(提交后后台处理、完成后通知)。
## 关键代码
完整代码和测试见 [examples/batch-fetch](../examples/batch-fetch/),核心部分:
```go
sem := make(chan struct{}, limit) // 并发上限
for i, id := range ids {
wg.Add(1)
go func() {
defer wg.Done()
select {
case sem <- struct{}{}:
case <-ctx.Done(): // 整体超时后,没开始的请求不再发
results[i] = Result{ID: id, Err: ctx.Err()}
return
}
defer func() { <-sem }()
results[i] = fetchOne(ctx, client, baseURL, id, perReq) // 内部再套单次超时
}()
}
wg.Wait()
```
## 取舍
| 方案 | 优点 | 缺点 |
| --- | --- | --- |
| 串行调用 | 简单,不会触发限流 | 太慢 |
| 每个订单一个 goroutine,不限并发 | 写法简单 | 被限流、连接数暴涨,下游故障时拖垮自己 |
| **信号量 + 两层超时(本方案)** | 速度和稳定性平衡,代码量小 | 单机限流,多实例需要 Redis 全局限流 |
| 异步任务 + 消息队列 | 能处理上万条、可重试 | 交互变成“提交—等待通知”,复杂度高 |
选择:几百条以内用本方案;超过几千条或需要可靠重试时改成异步任务。
## 易错点
- 只设整体超时、不设单次超时:一个卡住的请求会一直占着并发名额。
- 用 `http.DefaultClient`:它没有超时,生产代码要自己创建 `http.Client` 并设置 `Timeout`,或者每个请求都带 context。
- 忘了 `resp.Body.Close()`:连接无法复用,最终耗尽连接。
- 对 429 / 5xx 立即重试:会让限流更严重;重试要有退避和次数上限,最好只重试幂等的查询。
- 多个 goroutine 同时 `append` 同一个切片:数据竞争,用下标写入或加锁。
## 面试怎么讲
> “我们有个批量查物流的功能,最早串行调用太慢,改成全并发又被第三方限流。我用带缓冲的 channel 做信号量把并发控制在对方允许的范围内,整体请求和单次调用分别设超时,每个订单独立记录成功或失败,最后返回部分成功的结果,前端可以单独重试失败的。测试里用 httptest 模拟慢请求和 500,验证并发上限、超时和结果顺序。如果数据量再大,我会改成异步任务加消息队列。”
可能的追问:
- 多实例部署时怎么保证总并发不超过 10?→ Redis 分布式限流或者集中到一个调用服务。
- 为什么不用 `errgroup`?→ `errgroup` 默认“一个失败全部取消”,这里需要部分失败;新版 `errgroup` 的 `SetLimit` 也能限并发,可以按需选择。
- 怎么知道限流参数合不合适?→ 监控第三方的 429 比例和耗时分布,逐步调整。