面试题集锦:Go 进阶追问

面试题集锦:Go 进阶追问

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 ContextJava
取消信号Done channel + cancel funcThread.interrupt() / ExecutorService.shutdown()
超时控制WithTimeout 直接支持CompletableFuture.orTimeout()
值传递context.WithValueThreadLocal / 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;
});
维度GoJava
错误传递返回 errorthrow 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 连接池配置原则

场景MaxOpenConnsMaxIdleConns备注
高并发 APIDB 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. 参考资料

  1. Go Context: https://go.dev/blog/context
  2. Redis 分布式锁: https://redis.io/docs/manual/patterns/distributed-locks/
  3. etcd client: https://etcd.io/docs/
  4. golang.org/x/sync/errgroup: https://pkg.go.dev/golang.org/x/sync/errgroup
  5. go-redis: https://github.com/redis/go-redis
  6. MongoDB driver: https://www.mongodb.com/docs/drivers/go/