架构与系统设计 / 系统课时

设计负载削减与准入控制

设计负载削减与准入控制

过载时最危险的做法不是拒绝请求,而是把所有请求都塞进队列,最终让它们一起超时。本课用 Deadline、有界等待队列、执行并发上限和优先级组成准入门,主动削减低价值负载,为核心 RPC 保留可用容量。

学习目标

  • 能按 Deadline、优先级、等待队列和执行并发设计准入顺序
  • 能用 gRPC Unary Interceptor 在业务处理前拒绝过载请求
  • 能用压测指标判断削减是否真正保护了核心 RPC

先把过载变成可控拒绝

Load shedding 的目标不是“让错误率变成零”,而是在容量不足时把失败限制在入口。请求一旦进入昂贵的数据库查询、下游调用或大对象计算,再超时退出,已经消耗了最稀缺的资源,还会继续推高排队时间。

一个实用的准入链路可以按“剩余 Deadline → 优先级 → 执行容量 → 有界等待”组织:Deadline 明显不足时尽早返回;核心流量可以使用普通流量不可占用的部分执行容量;执行槽位暂时不足时,只允许有限数量的请求等待;等待区已满则立即拒绝。

gRPC 负载削减与准入控制链路

组合四道准入门槛

Deadline 应先筛掉注定失败的请求。服务端可以读取请求上下文的剩余时间;如果预算已经低于该方法可接受的最小处理时间,继续排队只会制造无效工作。阈值应来自该 RPC 的实际耗时分布,而不是凭经验随意设置。

优先级必须和保留容量绑定。仅给请求打标签没有意义;核心流量要能使用普通流量不可占用的一部分执行容量。优先级应由服务端根据认证身份、方法或业务规则映射,不能直接相信任意客户端自报的高优先级。

等待队列必须有硬上限,而且只统计尚未获得执行槽位的请求。请求从等待态切换到执行态时,应先减少 waiting,再增加运行中计数;这两个动作最好在同一把锁下完成,避免把正在执行的 RPC 继续算进队列。

执行并发约束真正的稀缺资源。并发上限可以对应 CPU、数据库连接、下游并发或昂贵任务数。若不同 RPC 成本差异很大,应按方法或资源池拆分容量,而不是只限制进程级请求总数。

用 Unary Interceptor 分离等待与执行

下面的可运行示例放在已经安装 google.golang.org/grpc 的 Go module 中。waiting 只统计排队请求;runningTotal 和 runningBulk 只统计 Handler 中正在执行的请求。maxTotal=2、maxBulk=1 表示最多同时执行两个 RPC,但普通流量最多占一个槽位,因此另一个槽位可供核心流量使用。

go
package main

import (
    "context"
    "fmt"
    "sync"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/metadata"
    "google.golang.org/grpc/status"
)

type gate struct {
    mu sync.Mutex

    changed chan struct{}

    waiting      int
    maxQueue     int
    runningTotal int
    maxTotal     int
    runningBulk  int
    maxBulk      int
    minBudget    time.Duration
}

func newGate(maxQueue, maxTotal, maxBulk int, minBudget time.Duration) *gate {
    return &gate{
        changed:   make(chan struct{}),
        maxQueue:  maxQueue,
        maxTotal:  maxTotal,
        maxBulk:   maxBulk,
        minBudget: minBudget,
    }
}

func (g *gate) signalLocked() {
    close(g.changed)
    g.changed = make(chan struct{})
}

func (g *gate) canStartLocked(core bool) bool {
    if g.runningTotal >= g.maxTotal {
        return false
    }
    return core || g.runningBulk < g.maxBulk
}

func (g *gate) startLocked(core bool) func() {
    g.runningTotal++
    if !core {
        g.runningBulk++
    }

    return func() {
        g.mu.Lock()
        defer g.mu.Unlock()

        g.runningTotal--
        if !core {
            g.runningBulk--
        }
        g.signalLocked()
    }
}

func (g *gate) acquire(ctx context.Context, core bool) (func(), error) {
    g.mu.Lock()

    // 有执行容量时直接进入执行态,不占用等待队列。
    if g.canStartLocked(core) {
        release := g.startLocked(core)
        g.mu.Unlock()
        return release, nil
    }

    // 只有真正等待执行槽位的请求才计入 waiting。
    if g.waiting >= g.maxQueue {
        g.mu.Unlock()
        return nil, status.Error(codes.ResourceExhausted, "admission queue full")
    }
    g.waiting++

    for {
        changed := g.changed
        g.mu.Unlock()

        select {
        case <-ctx.Done():
            g.mu.Lock()
            g.waiting--
            g.signalLocked()
            g.mu.Unlock()
            return nil, status.FromContextError(ctx.Err()).Err()
        case <-changed:
        }

        g.mu.Lock()
        if err := ctx.Err(); err != nil {
            g.waiting--
            g.signalLocked()
            g.mu.Unlock()
            return nil, status.FromContextError(err).Err()
        }
        if g.canStartLocked(core) {
            // 等待态 -> 执行态在同一临界区完成,Handler 期间不再占 queue。
            g.waiting--
            release := g.startLocked(core)
            g.mu.Unlock()
            return release, nil
        }
    }
}

func (g *gate) unary(
    ctx context.Context,
    req any,
    _ *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler,
) (any, error) {
    if d, ok := ctx.Deadline(); ok && time.Until(d) < g.minBudget {
        return nil, status.Error(codes.DeadlineExceeded, "insufficient deadline budget")
    }

    // 演示直接读取 metadata;生产环境应从可信身份或方法策略映射优先级。
    core := false
    if md, ok := metadata.FromIncomingContext(ctx); ok {
        values := md.Get("x-priority")
        core = len(values) > 0 && values[0] == "core"
    }

    release, err := g.acquire(ctx, core)
    if err != nil {
        return nil, err
    }
    defer release()

    return handler(ctx, req)
}

func call(g *gate, priority string, timeout time.Duration) codes.Code {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    ctx = metadata.NewIncomingContext(
        ctx,
        metadata.Pairs("x-priority", priority),
    )
    _, err := g.unary(ctx, nil, nil, func(context.Context, any) (any, error) {
        return "ok", nil
    })
    return status.Code(err)
}

func waitForWaiting(g *gate, want int) {
    for {
        g.mu.Lock()
        got := g.waiting
        g.mu.Unlock()
        if got == want {
            return
        }
        time.Sleep(time.Millisecond)
    }
}

func main() {
    g := newGate(1, 2, 1, 50*time.Millisecond)

    // 第一个普通 RPC 占住普通执行槽位。
    started := make(chan struct{})
    releaseFirst := make(chan struct{})
    go func() {
        ctx := metadata.NewIncomingContext(
            context.Background(),
            metadata.Pairs("x-priority", "normal"),
        )
        _, _ = g.unary(ctx, nil, nil, func(context.Context, any) (any, error) {
            close(started)
            <-releaseFirst
            return "ok", nil
        })
    }()
    <-started

    // 第二个普通 RPC 只能进入唯一的等待槽位。
    queuedDone := make(chan codes.Code, 1)
    go func() {
        queuedDone <- call(g, "normal", time.Second)
    }()
    waitForWaiting(g, 1)

    fmt.Println("third-normal:", call(g, "normal", time.Second))
    fmt.Println("core:", call(g, "core", time.Second))
    fmt.Println("short-deadline:", call(g, "core", 20*time.Millisecond))

    close(releaseFirst)
    fmt.Println("queued-normal:", <-queuedDone)
}

运行命令:

bash
go run .

预期输出:

text
third-normal: ResourceExhausted
core: OK
short-deadline: DeadlineExceeded
queued-normal: OK

第一个普通请求正在执行,第二个普通请求只占一个等待槽位,因此第三个普通请求因等待区已满被削减;核心请求仍可使用第二个总执行槽位。释放第一个请求后,排队请求在同一临界区内先执行 waiting--,再增加运行中计数,因此 Handler 执行期间不会继续占用 queue。

这个示例把“等待数”和“运行数”拆成了两个独立状态,但为了突出核心机制,等待队列仍是共享的,也没有实现 FIFO、公平排队或每类流量独立的等待配额。生产环境如果需要更强的租户隔离,应继续按方法、优先级或资源池拆分队列和执行容量。

用压测指标验证保护效果

调参时不要只看总体成功率。至少同时观察按原因分类的准入拒绝数、等待队列长度与等待时间 P95/P99、正在执行的 RPC 数、核心 RPC 的成功率与尾延迟,以及 CPU、连接池和下游并发。压测应逐步把流量推过容量拐点,确认普通请求开始排队或被削减后,核心 RPC 的延迟仍保持稳定。

负载削减真正要保护的是“有价值的完成量”,而不是“尽量少拒绝”。只有把等待请求与正在执行的请求分别计量,才能独立设置排队窗口、执行容量和优先级保留,并在容量下降时尽早拒绝低价值或注定超时的工作。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

设计负载削减与准入控制

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通