
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
1. Context 取消与超时
1.1 概念定义
一句话描述:Context 是 Go 官方设计的请求级取消信号传递机制,用于在 goroutine 之间传播取消指令、截止时间和请求范围的值。
1.2 Context 核心接口
type Context interface {
// Deadline 返回截止时间,ok=false 表示无截止
Deadline() (deadline time.Time, ok bool)
// Done 返回一个被关闭的 channel,当 context 取消时关闭
Done() <-chan struct{}
// Err 解释为什么 Done channel 被关闭
Err() error
// Value 返回此 context 中存储的值
Value(key any) any
}1.3 四种 Context 创建方式
// 1. context.Background() - 根 context,通常用于 main() 或最高层级
ctx := context.Background()
// 2. context TODO() - 当不确定用哪个时占位
ctx := context.TODO()
// 3. context.WithCancel() - 手动取消
ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 必须调用,防止泄漏
// 4. context.WithTimeout() - 超时自动取消
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
// 5. context.WithDeadline() - 绝对时间截止
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Hour))
defer cancel()
// 6. context.WithValue() - 传递请求级数据
ctx := context.WithValue(ctx, "traceID", "abc123")1.4 取消传播机制
┌─────────────────────────────────────────────────────────────────┐
│ context 树传播 │
│ │
│ Background │
│ │ │
│ ├── WithCancel (cancelChan) ──→ channel A ──→ G1 │
│ │ └──→ G2 │
│ │ │
│ └── WithTimeout(5s) ──────────────────→ channel B ──→ G3 │
│ └──→ G4 │
│ │
│ 当调用 cancel() 或超时: │
│ → 关闭 Done channel │
│ → 所有监听 Done 的 goroutine 收到信号并退出 │
└─────────────────────────────────────────────────────────────────┘
1.5 实际项目示例
文件: internal/service/message/message_service.go
// 模拟批量操作支持取消
func (s *MessageService) SendBatchMessages(ctx context.Context, userIDs []string, msg *Message) error {
// 创建子 context,带 30 秒超时
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
// 使用 errgroup 并发处理
g, ctx := errgroup.WithContext(ctx)
// 限制并发数
sem := make(chan struct{}, 100)
for _, userID := range userIDs {
userID := userID // 捕获循环变量
g.Go(func() error {
select {
case <-ctx.Done():
return ctx.Err() // 上下文取消时立即返回
case sem <- struct{}{}:
defer func() { <-sem }()
}
// 发送消息
return s.sendToUser(ctx, userID, msg)
})
}
return g.Wait()
}文件: internal/api/handler/chat/chat_handler.go
// HTTP 请求中使用 context
func (h *ChatHandler) SendMessage(c *hertz.RequestContext) {
var req SendMessageRequest
if err := c.BindAndValidate(&req); err != nil {
response.BadRequest(c, err.Error())
return
}
// 从请求 context 获取(可能已被中间件取消)
ctx := c.Request.Context()
// 将 context 传递给下层服务
err := h.chatService.SendMessage(ctx, req.UserID, req.Content)
if err != nil {
if ctx.Err() == context.Canceled {
response.Unauthorized(c, "请求已被取消")
return
}
response.InternalError(c, err.Error())
return
}
response.Success(c, nil)
}1.6 中间件中的 Context
// 超时中间件
func TimeoutMiddleware(timeout time.Duration) middleware.Handler {
return func(c *hertz.RequestContext) {
ctx, cancel := context.WithTimeout(c.Request.Context(), timeout)
defer cancel()
// 用带超时的 context 替换原 context
c.Request.SetContext(ctx)
c.Next()
}
}
// 取消信号中间件
func CancelSignalMiddleware() middleware.Handler {
return func(c *hertz.RequestContext) {
ctx := c.Request.Context()
// 监听 context 取消信号
go func() {
select {
case <-ctx.Done():
// 客户端断开连接
h.log.CtxInfof(c, "client disconnected: %v", ctx.Err())
}
}()
c.Next()
}
}1.7 与 Java 对比
| 维度 | Go Context | Java |
|---|---|---|
| 取消信号 | Done channel + cancel func | Thread.interrupt() / ExecutorService.shutdown() |
| 超时控制 | WithTimeout 直接支持 | CompletableFuture.orTimeout() |
| 值传递 | context.WithValue | ThreadLocal / RequestAttributes |
| 传播方式 | 沿着 goroutine 树自动传播 | 需手动传递 ThreadLocal |
| 树形结构 | 支持父子 context | 不支持 |
1.8 常见面试问题
Q1: context 泄漏的原因?
// ❌ 错误:忘记调用 cancel
ctx, cancel := context.WithCancel(context.Background())
go func() {
<-ctx.Done()
// 永远等待,因为 cancel 从未被调用
}()
// ✓ 正确:defer cancel
ctx, cancel := context.WithCancel(context.Background())
defer cancel()Q2: context.Value 的坑?
// 1. nil key panic
ctx.Value(nil) // panic
// 2. 频繁查找性能差(内部用链表实现)
// 解决方案:用 request ID 等关键数据,不要滥用
// 3. 类型不安全
traceID := ctx.Value("traceID").(string) // 可能 panic
// 正确写法:
if v := ctx.Value("traceID"); v != nil {
traceID = v.(string)
}2. 分布式并发:Redis 与 etcd 分布式锁
2.1 概念定义
一句话描述:分布式锁用于在多个进程/服务实例之间协调对共享资源的独占访问,Go 中常用 Redis 或 etcd 实现。
2.2 Redis 分布式锁
// 分布式锁实现
type DistributedLock struct {
redis *redis.Client
key string
value string // 锁持有者标识
expiry time.Duration
}
func NewDistributedLock(redis *redis.Client, key string, expiry time.Duration) *DistributedLock {
return &DistributedLock{
redis: redis,
key: key,
value: uuid.New().String(), // 唯一标识
expiry: expiry,
}
}
// 加锁
func (l *DistributedLock) Lock(ctx context.Context) (bool, error) {
// SET key value NX PX milliseconds
result, err := l.redis.SetNX(ctx, l.key, l.value, l.expiry).Result()
if err != nil {
return false, fmt.Errorf("redis setnx: %w", err)
}
return result, nil
}
// 解锁(Lua 脚本保证原子性)
func (l *DistributedLock) Unlock(ctx context.Context) error {
// Lua 脚本:只有锁持有者才能释放
script := `
if redis.call("get", KEYS[1]) == ARGV[1] then
return redis.call("del", KEYS[1])
else
return 0
end
`
_, err := l.redis.Eval(ctx, script, []string{l.key}, l.value).Result()
return err
}2.3 Redis 锁实战使用
// 订单库存扣减
func (s *OrderService) DecreaseStock(ctx context.Context, productID string, quantity int) error {
lock := redislock.NewDistributedLock(s.redis, "stock:"+productID, 10*time.Second)
// 加锁
ok, err := lock.Lock(ctx)
if err != nil {
return fmt.Errorf("acquire lock failed: %w", err)
}
if !ok {
return errors.New("lock held by others")
}
defer func() {
if err := lock.Unlock(ctx); err != nil {
s.log.CtxErrorf(ctx, "unlock failed: %v", err)
}
}()
// 业务逻辑:扣减库存
stock, err := s.GetStock(ctx, productID)
if err != nil {
return err
}
if stock < quantity {
return errors.New("insufficient stock")
}
return s.SetStock(ctx, productID, stock-quantity)
}2.4 Redis 锁的缺陷与 Redlock
单 Redis 实例的问题:如果 master 故障,可能导致锁丢失。
Redlock 算法(5 个独立 Redis 实例):
// Redlock 简化实现
func (r *Redlock) Lock(ctx context.Context, key string, ttl time.Duration) error {
keys := r.getKeys(key) // 5 个 key: key, key-2, key-3, key-4, key-5
var successes int
for _, client := range r.clients {
ok, _ := client.SetNX(ctx, key, uuid.New().String(), ttl).Result()
if ok {
successes++
}
}
// 超过半数成功才算加锁成功
if successes < len(r.clients)/2+1 {
return errors.New("insufficient lock acquisitions")
}
return nil
}实际建议:除非对一致性要求极高(如金融场景),单 Redis 实例锁足够。
2.5 etcd 分布式锁
// etcd 锁实现(使用 clientv3)
import (
"go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency"
)
type EtcdLock struct {
client *clientv3.Client
key string
}
func NewEtcdLock(client *clientv3.Client, key string) *EtcdLock {
return &EtcdLock{
client: client,
key: key,
}
}
func (l *EtcdLock) Lock(ctx context.Context) error {
// 创建 session
session, err := concurrency.NewSession(l.client)
if err != nil {
return err
}
// 创建 mutex
mu := concurrency.NewMutex(session, l.key)
// 获取锁(带超时)
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
return mu.Lock(ctx)
}
func (l *EtcdLock) Unlock(ctx context.Context) error {
// mutex 解锁自动在 session 关闭时完成
return nil
}2.6 Redis vs etcd 锁对比
| 维度 | Redis 锁 | etcd 锁 |
|---|---|---|
| 一致性 | AP(最终一致) | CP(强一致) |
| 性能 | 极高 | 较高 |
| 锁过期 | 需考虑续期 | 自动续期(session) |
| 公平性 | 非公平 | 公平(FIFO) |
| 适用场景 | 普通并发控制 | 高一致性要求 |
| 复杂度 | 简单 | 需维护 etcd 集群 |
2.7 常见面试问题
Q1: Redis 锁过期了但业务还没执行完怎么办?
// 方案:看门狗自动续期
type LockWithWatchdog struct {
lock *DistributedLock
ttl time.Duration
renewTick *time.Ticker
}
func (l *LockWithWatchdog) AutoRenew(ctx context.Context) {
l.renewTick = time.NewTicker(l.ttl / 3) // 每 1/3 TTL 续期一次
go func() {
for {
select {
case <-ctx.Done():
return
case <-l.renewTick.C:
l.lock.Extend(ctx, l.ttl)
}
}
}()
}Q2: Redis 锁的 value 用什么?
// ❌ 错误:用固定值
lock.Lock(ctx) // value = "1"
unlock(ctx) // 任何人都能解锁
// ✓ 正确:用唯一值(如 UUID)
lock := &DistributedLock{
value: uuid.New().String(), // 只有持有者才能解锁
}3. 并发模式实战
3.1 Pipeline 管道模式
// Pipeline:数据像管道一样流经多个处理阶段
func Pipeline(ctx context.Context, data <-chan int) (<-chan int, <-chan error) {
out := make(chan int, 100)
errCh := make(chan error, 1)
go func() {
defer close(out)
defer close(errCh)
// Stage 1: 平方
squared := make(chan int, 100)
go func() {
defer close(squared)
for v := range data {
select {
case <-ctx.Done():
return
case squared <- v * v:
}
}
}()
// Stage 2: 过滤偶数
for v := range squared {
if v%2 == 0 {
select {
case <-ctx.Done():
return
case out <- v:
}
}
}
}()
return out, errCh
}3.2 Fan-Out / Fan-In 扇入扇出
// Fan-Out: 多个 worker 处理同一输入
func FanOut(ctx context.Context, input <-chan Job, workers int) <-chan Result {
results := make(chan Result, workers*10)
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
for job := range input {
select {
case <-ctx.Done():
return
case results <- process(job):
}
}
}(i)
}
go func() {
wg.Wait()
close(results)
}()
return results
}
// Fan-In: 合并多个 channel 到一个
func Merge(ctx context.Context, chans ...<-chan int) <-chan int {
out := make(chan int)
var wg sync.WaitGroup
for _, ch := range chans {
wg.Add(1)
go func(c <-chan int) {
defer wg.Done()
for v := range c {
select {
case <-ctx.Done():
return
case out <- v:
}
}
}(ch)
}
go func() {
wg.Wait()
close(out)
}()
return out
}3.3 Worker Pool worker 池
// 通用 worker 池
type WorkerPool struct {
jobs chan Job
results chan Result
workers int
wg sync.WaitGroup
}
type Job struct {
ID string
Data interface{}
}
type Result struct {
ID string
Value interface{}
Err error
}
func NewWorkerPool(workers, queueSize int) *WorkerPool {
return &WorkerPool{
jobs: make(chan Job, queueSize),
results: make(chan Result, queueSize),
workers: workers,
}
}
func (wp *WorkerPool) Start(ctx context.Context) {
for i := 0; i < wp.workers; i++ {
wp.wg.Add(1)
go wp.worker(ctx, i)
}
}
func (wp *WorkerPool) worker(ctx context.Context, id int) {
defer wp.wg.Done()
for job := range wp.jobs {
select {
case <-ctx.Done():
return
default:
result := Result{
ID: job.ID,
Value: processJob(job),
}
select {
case wp.results <- result:
case <-ctx.Done():
return
}
}
}
}
func (wp *WorkerPool) Submit(job Job) {
wp.jobs <- job
}
func (wp *WorkerPool) Stop() {
close(wp.jobs)
wp.wg.Wait()
close(wp.results)
}3.4 errgroup 并发错误处理
// golang.org/x/sync/errgroup
import "golang.org/x/sync/errgroup"
func FetchUserData(ctx context.Context, userID string) (*UserData, error) {
g, ctx := errgroup.WithContext(ctx)
var profile *Profile
var posts []*Post
var friends []*Friend
// 并发获取
g.Go(func() error {
var err error
profile, err = fetchProfile(ctx, userID)
return err
})
g.Go(func() error {
var err error
posts, err = fetchPosts(ctx, userID)
return err
})
g.Go(func() error {
var err error
friends, err = fetchFriends(ctx, userID)
return err
})
// 等待所有完成,如果有任何一个失败,context 被取消
if err := g.Wait(); err != nil {
return nil, err
}
return &UserData{
Profile: profile,
Posts: posts,
Friends: friends,
}, nil
}3.5 限流器
// 令牌桶限流
type RateLimiter struct {
rate float64 // 令牌/秒
burst int // 桶大小
tokens float64
lastTime time.Time
mu sync.Mutex
}
func NewRateLimiter(rate float64, burst int) *RateLimiter {
return &RateLimiter{
rate: rate,
burst: burst,
tokens: float64(burst),
lastTime: time.Now(),
}
}
func (rl *RateLimiter) Allow() bool {
return rl.AllowN(time.Now(), 1)
}
func (rl *RateLimiter) AllowN(now time.Time, n int) bool {
rl.mu.Lock()
defer rl.mu.Unlock()
// 补充令牌
elapsed := now.Sub(rl.lastTime).Seconds()
rl.tokens += elapsed * rl.rate
if rl.tokens > float64(rl.burst) {
rl.tokens = float64(rl.burst)
}
rl.lastTime = now
// 消费令牌
if rl.tokens >= float64(n) {
rl.tokens -= float64(n)
return true
}
return false
}4. 错误处理与重试机制
4.1 Go 错误哲学
// Go 错误 vs Java 异常
// Go: 错误是值,调用者必须处理
func readFile(name string) ([]byte, error) {
data, err := os.ReadFile(name)
if err != nil {
return nil, fmt.Errorf("read file %s: %w", name, err)
}
return data, nil
}
// Java: 异常机制,调用者可以 try-catch 或继续抛出
// public byte[] readFile(String name) throws IOException { ... }4.2 错误包装与解包
// 错误包装(保留原错误链)
err := os.ErrNotExist
wrapped := fmt.Errorf("failed to read config: %w", err)
// 错误解包(还原原错误)
if errors.Is(wrapped, os.ErrNotExist) {
// 文件不存在
}
// 类型断言(判断错误类型)
var pathErr *os.PathError
if errors.As(err, &pathErr) {
fmt.Println("path:", pathErr.Path)
}4.3 自定义错误类型
// 定义业务错误
type BusinessError struct {
Code int
Message string
Cause error
}
func (e *BusinessError) Error() string {
return e.Message
}
func (e *BusinessError) Unwrap() error {
return e.Cause
}
// 创建错误
func ErrInsufficientStock(productID string, available, requested int) *BusinessError {
return &BusinessError{
Code: 13001,
Message: fmt.Sprintf("insufficient stock for %s: available=%d, requested=%d",
productID, available, requested),
}
}
// 判断错误
if errors.Is(err, ErrInsufficientStock("", 0, 0)) {
// 库存不足
}4.4 重试机制
// 通用重试配置
type RetryConfig struct {
MaxAttempts int // 最大重试次数
InitialWait time.Duration // 初始等待时间
MaxWait time.Duration // 最大等待时间
Factor float64 // 退避因子
}
// 指数退避重试
func WithRetry(ctx context.Context, config RetryConfig, fn func() error) error {
var err error
wait := config.InitialWait
for attempt := 0; attempt < config.MaxAttempts; attempt++ {
if err = fn(); err == nil {
return nil
}
// 检查是否为可重试错误
if !isRetryable(err) {
return err
}
// 最后一次尝试不需要等待
if attempt == config.MaxAttempts-1 {
break
}
// 等待后重试
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(wait):
}
// 指数退避
wait = time.Duration(float64(wait) * config.Factor)
if wait > config.MaxWait {
wait = config.MaxWait
}
}
return fmt.Errorf("after %d attempts: %w", config.MaxAttempts, err)
}
// 判断是否可重试
func isRetryable(err error) bool {
// 网络错误、超时等可重试
// 业务错误(库存不足)通常不可重试
if errors.Is(err, context.DeadlineExceeded) {
return true
}
var e *net.OpError
if errors.As(err, &e) {
return true
}
return false
}4.5 重试与熔断器
// 熔断器实现
type CircuitBreaker struct {
mu sync.Mutex
state State
failures int
lastFailure time.Time
threshold int // 触发熔断的失败次数
timeout time.Duration // 熔断恢复时间
}
type State int
const (
StateClosed State = iota // 正常
StateOpen // 熔断
StateHalfOpen // 半开
)
func (cb *CircuitBreaker) Call(ctx context.Context, fn func() error) error {
cb.mu.Lock()
switch cb.state {
case StateOpen:
// 检查是否超时
if time.Since(cb.lastFailure) > cb.timeout {
cb.state = StateHalfOpen
} else {
cb.mu.Unlock()
return errors.New("circuit breaker open")
}
}
cb.mu.Unlock()
// 执行调用
err := fn()
cb.mu.Lock()
defer cb.mu.Unlock()
if err != nil {
cb.failures++
cb.lastFailure = time.Now()
if cb.failures >= cb.threshold {
cb.state = StateOpen
}
return err
}
// 成功,重置
cb.state = StateClosed
cb.failures = 0
return nil
}4.6 Java 对比
// Java 异常处理
try {
readFile();
} catch (IOException e) {
// 检查类型
if (e instanceof FileNotFoundException) {
// 处理找不到文件
}
throw e; // 重新抛出
} finally {
// 清理资源
}
// Java 重试机制 - Guava Retryer
Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()
.retryIfExceptionOfType(IOException.class)
.withWaitStrategy(WaitStrategies.exponentialWait())
.withStopStrategy(StopStrategies.stopAfterAttempt(3))
.build();
retryer.call(() -> {
// 业务逻辑
return true;
});| 维度 | Go | Java |
|---|---|---|
| 错误传递 | 返回 error | throw exception |
| 编译时检查 | 无 | checked exception |
| 错误链 | %w 包装 | getCause() |
| 重试机制 | 手动实现/第三方库 | Guava Retryer |
| 熔断器 | 手动实现/第三方库 | Resilience4j |
5. 数据库连接池
5.1 Go sql.DB 连接池
import "database/sql"
// sql.DB 是连接池,不是单个连接
db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/db")
if err != nil {
log.Fatal(err)
}
// 关键配置
db.SetMaxOpenConns(100) // 最大打开连接数
db.SetMaxIdleConns(20) // 最大空闲连接数
db.SetConnMaxLifetime(time.Hour) // 连接最大生命周期
db.SetConnMaxIdleTime(30 * time.Minute) // 空闲连接超时
// 使用
row := db.QueryRowContext(ctx, "SELECT * FROM users WHERE id = ?", id)
var user User
err := row.Scan(&user)
// 连接池自动管理:
// - 空闲连接复用
// - 连接超时
// - 空闲连接清理5.2 MongoDB 连接池
import "go.mongodb.org/mongo-driver/mongo"
clientOpts := options.Client().
ApplyURI("mongodb://localhost:27017").
SetMaxPoolSize(100). // 最大连接数
SetMinPoolSize(10). // 最小连接数
SetMaxConnIdleTime(30 * time.Second)
// 获取 collection
collection := client.Database("myapp").Collection("users")
// 使用 context 控制超时
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
cursor, err := collection.Find(ctx, bson.M{"status": "active"})5.3 Redis 连接池
import "github.com/redis/go-redis/v9"
client := redis.NewClusterClient(&redis.ClusterOptions{
Addrs: []string{"localhost:7000", "localhost:7001", "localhost:7002"},
PoolSize: 100, // 每个节点 100 连接
MinIdleConns: 10, // 最小空闲
ReadTimeout: 3 * time.Second,
WriteTimeout: 3 * time.Second,
PoolTimeout: 4 * time.Second, // 等待连接超时
})
// Pipeline 减少 RTT
pipe := client.Pipeline()
pipe.Set(ctx, "key1", "value1", 0)
pipe.Get(ctx, "key2")
pipe.HSet(ctx, "key3", map[string]string{"f1": "v1"})
_, err := pipe.Exec(ctx)5.4 连接池配置原则
| 场景 | MaxOpenConns | MaxIdleConns | 备注 |
|---|---|---|---|
| 高并发 API | DB CPU × 2~4 | 与 MaxOpenConns 接近 | 减少连接等待 |
| 后台任务 | 较低(10-50) | 可等于 MaxOpenConns | 任务不紧急 |
| 查询为主 | 可较高 | 接近 MaxOpenConns | 读操作释放快 |
| 写入为主 | 较低 | 较小 | 写操作持有时间长 |
5.5 常见问题
Q1: 连接泄漏如何排查?
// 开启连接统计
stats := db.Stats()
fmt.Printf("Open: %d, InUse: %d, Idle: %d\n",
stats.OpenConnections,
stats.InUse,
stats.Idle)
// 设置最大生命周期避免僵尸连接
db.SetConnMaxLifetime(10 * time.Minute)Q2: 连接数过多怎么办?
// 1. 限流
limiter := make(chan struct{}, 100)
for i := 0; i < 1000; i++ {
limiter <- struct{}{}
go func() {
defer func() { <-limiter }()
// 查询
}()
}
// 2. 使用 context 超时
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
db.QueryRowContext(ctx, "SELECT ...")
// 3. 减少事务持有时间
// 错误:长事务
tx, _ := db.Begin()
// 很多业务逻辑
tx.Commit()
// 正确:短事务
doBusinessLogic()
tx, _ := db.Begin()
tx.Exec("UPDATE ...")
tx.Commit()6. 参考资料
- Go Context: https://go.dev/blog/context
- Redis 分布式锁: https://redis.io/docs/manual/patterns/distributed-locks/
- etcd client: https://etcd.io/docs/
- golang.org/x/sync/errgroup: https://pkg.go.dev/golang.org/x/sync/errgroup
- go-redis: https://github.com/redis/go-redis
- MongoDB driver: https://www.mongodb.com/docs/drivers/go/