Go并发模型深度剖析，从goroutine到channel——尹成20年高并发项目实战浓缩

第一章：Go并发模型的核心哲学与设计思想

Go 并发不是对传统线程模型的简单封装，而是一套以“轻量、组合、解耦”为内核的全新编程范式。其设计思想根植于 Tony Hoare 的 CSP（Communicating Sequential Processes）理论——并发实体不通过共享内存通信，而是通过通道传递消息。这一原则直接塑造了 goroutine 与 channel 的共生关系：goroutine 是廉价的执行单元（初始栈仅 2KB，按需动态扩容），channel 是类型安全的同步信道，二者共同构成 Go 并发的原子语义单元。

Goroutine 的本质是协作式调度的用户态线程

运行时通过 GMP 模型（Goroutine、Machine、Processor）实现高效复用：

• G 代表协程，无 OS 级上下文切换开销；
• M 映射 OS 线程，P 提供运行队列与调度上下文；
• 当 G 阻塞（如 I/O 或 channel 操作）时，M 可脱离 P 去执行系统调用，而其他 M 继续调度剩余 G。

Channel 是唯一推荐的同步原语

避免使用 sync.Mutex 等显式锁进行状态协调，优先采用 channel 实现“通过通信共享内存”：

// 安全的生产者-消费者模式：无需锁，天然阻塞同步
ch := make(chan int, 10) // 缓冲通道，容量10

go func() {
    for i := 0; i < 5; i++ {
        ch <- i // 发送：若缓冲满则阻塞，直到有接收者
    }
    close(ch) // 关闭通道，通知消费者结束
}()

for v := range ch { // 接收：自动阻塞等待，通道关闭后退出循环
    fmt.Println("Received:", v)
}

并发错误的预防性设计

Go 运行时内置竞态检测器（race detector），可在开发阶段暴露数据竞争：

go run -race main.go  # 启用竞态检测
# 或构建时加入：go build -race -o app main.go

设计原则	具体体现	反模式示例
不要通过共享内存通信	使用 channel 传递数据而非全局变量赋值	多个 goroutine 直接读写同一 map
为失败而设计	select 默认分支处理非阻塞尝试	忽略 channel 关闭导致 panic
并发即函数式组合	go f() 启动即完成，后续逻辑独立	在 goroutine 内部嵌套阻塞调用

第二章：goroutine的底层实现与高效调度

2.1 goroutine的内存结构与栈管理机制

goroutine并非绑定到OS线程，其轻量性源于独特的内存布局：每个goroutine拥有独立的栈空间（初始2KB）、G结构体（元信息）和调度上下文。

栈的动态伸缩机制

Go采用分段栈（segmented stack）→连续栈（contiguous stack）演进策略。当检测到栈空间不足时，运行时自动分配新栈并复制旧数据：

func growStack() {
    // 触发栈增长的典型场景：递归或大局部变量
    var buf [1024]byte // 超出初始栈容量
    _ = buf
}

此函数执行时触发runtime.morestack，将当前栈迁移至更大内存块，并更新g->stack指针；g->stackguard0同步更新为新栈边界阈值。

G结构体核心字段

字段	类型	说明
stack	stack	当前栈起止地址
stackguard0	uintptr	栈溢出检查哨兵地址
sched	gobuf	寄存器保存区，含SP、PC等

栈增长流程

graph TD
A[函数调用检测SP < stackguard0] --> B[调用runtime.morestack]
B --> C[分配新栈内存]
C --> D[复制旧栈数据]
D --> E[更新g.stack与g.sched.sp]
E --> F[跳转回原函数继续执行]

• 栈扩容无锁设计，但需暂停当前P上的M；
• 连续栈避免分段管理开销，提升缓存局部性。

2.2 GMP调度器工作原理与源码级剖析

GMP模型将 Goroutine（G）、Machine（M）和 Processor（P）三者解耦，实现用户态协程的高效调度。

核心调度循环

runtime.schedule() 是主调度入口，其关键逻辑如下：

func schedule() {
    // 1. 尝试从本地队列获取G
    gp := runqget(_g_.m.p.ptr())
    if gp != nil {
        execute(gp, false) // 执行G
        return
    }
    // 2. 若本地为空，尝试窃取其他P的队列
    gp = runqsteal(_g_.m.p.ptr(), true)
    if gp != nil {
        execute(gp, false)
        return
    }
}

runqget() 从 P 的本地运行队列（无锁、LIFO）弹出 Goroutine；runqsteal() 按固定顺序轮询其他 P，执行 Work-Stealing（偷取一半任务），避免全局锁竞争。

GMP状态流转

状态	含义	转换触发
_Grunnable	等待被调度	go f() 创建后
_Grunning	正在 M 上执行	execute() 加载上下文
_Gwaiting	阻塞（如 channel、syscall）	gopark()

调度流程概览

graph TD
    A[新建G] --> B[入P本地队列]
    B --> C{M空闲？}
    C -->|是| D[绑定M执行]
    C -->|否| E[唤醒或创建新M]
    D --> F[执行完毕/阻塞]
    F -->|阻塞| G[gopark → _Gwaiting]
    F -->|完成| H[G回收或复用]

2.3 高并发场景下goroutine泄漏的定位与修复实践

常见泄漏模式识别

• 未关闭的 channel 导致 range 永久阻塞
• time.AfterFunc 或 time.Ticker 未显式停止
• HTTP handler 中启动 goroutine 但未绑定生命周期

定位手段对比

工具	触发方式	实时性	适用阶段
pprof/goroutine	GET /debug/pprof/goroutine?debug=2	高	运行时诊断
runtime.NumGoroutine()	定期采样+告警阈值	中	监控预警

// 启动带超时控制的后台任务（修复示例）
func startWorker(ctx context.Context, ch <-chan int) {
    go func() {
        defer func() { 
            if r := recover(); r != nil {
                log.Printf("worker panic: %v", r)
            }
        }()
        for {
            select {
            case val := <-ch:
                process(val)
            case <-ctx.Done(): // 关键：响应取消信号
                log.Println("worker exited gracefully")
                return
            }
        }
    }()
}

该函数通过 context.Context 统一管理生命周期，select 中 ctx.Done() 分支确保 goroutine 可被主动终止；defer 提供 panic 安全兜底。参数 ctx 必须由调用方传入带超时或取消能力的上下文，如 context.WithTimeout(parent, 30*time.Second)。

泄漏复现与验证流程

graph TD
    A[模拟高并发请求] --> B[持续调用启动goroutine的API]
    B --> C[观察pprof/goroutine数量线性增长]
    C --> D[注入context并添加Done监听]
    D --> E[再次压测，确认goroutine数回落至基线]

2.4 协程池设计与动态负载均衡实战

协程池需兼顾资源复用与响应时效，核心在于任务分发策略与运行时状态感知。

动态权重调度机制

基于实时协程负载（待处理任务数、平均执行时长、CPU占用率）计算节点权重，实现自适应路由：

def calc_weight(worker: Worker) -> float:
    # 权重 = 基础容量 / (1 + 归一化负载因子)
    load_score = (
        0.4 * (worker.pending / MAX_PENDING) +
        0.3 * (worker.avg_duration / BASE_DURATION) +
        0.3 * (worker.cpu_usage / 100.0)
    )
    return max(0.1, 1.0 / (1 + load_score))  # 防止权重归零

该函数输出 [0.1, 1.0] 区间浮点权重，供加权轮询器（WeightedRoundRobin）实时选用。

负载指标采集维度

指标	采集频率	作用
pending任务数	每次入队	反映瞬时积压
avg_duration	滑动窗口	评估协程执行效率
cpu_usage	OS级采样	揭示底层资源瓶颈

扩缩容触发逻辑

• ✅ 自动扩容：连续3次检测到平均权重
• ❌ 自动缩容：空闲超60s且权重持续 > 0.8，优雅终止低负载协程

graph TD
    A[新任务到达] --> B{权重调度器}
    B --> C[选取最高权重Worker]
    C --> D[提交至其本地队列]
    D --> E[协程消费并上报指标]
    E --> B

2.5 百万级goroutine压测调优与性能拐点分析

压测基线构建

使用 pprof + runtime.ReadMemStats 实时采集指标，启动 10 万 goroutine 模拟轻量任务：

func spawnWorkers(n int, ch <-chan struct{}) {
    var wg sync.WaitGroup
    for i := 0; i < n; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            select {
            case <-ch: // 可中断信号
                return
            default:
                runtime.Gosched() // 避免调度饥饿
            }
        }()
    }
    wg.Wait()
}

此函数避免 go func(){...}() 的变量捕获陷阱；runtime.Gosched() 显式让出时间片，缓解初始调度抖动；ch 提供优雅退出通道。

性能拐点观测

在 30 万 → 80 万 goroutine 区间，P99 延迟陡增（+320%），GC pause 时间突破 12ms（见下表）：

Goroutine 数	GC Pause (ms)	Goroutines/MB heap
300k	2.1	142
600k	7.8	98
900k	15.3	61

调优关键路径

• 启用 GODEBUG=gctrace=1,madvdontneed=1 减少页回收延迟
• 将共享 channel 替换为 per-P 无锁队列（sync.Pool 缓存 worker state）
• 关键路径禁用 defer，改用显式错误处理

graph TD
    A[启动100w goroutine] --> B{调度器负载}
    B -->|P > 8且GOMAXPROCS未调优| C[OS线程争抢加剧]
    B -->|heap碎片率 > 40%| D[GC频次翻倍]
    C & D --> E[延迟拐点：62万]

第三章：channel的语义本质与同步范式

3.1 channel的底层数据结构与内存模型解析

Go 的 channel 是基于环形缓冲区（circular buffer）与同步原语构建的复合结构，核心字段包含 qcount（当前元素数）、dataqsiz（缓冲区容量）、buf（指向底层数组的指针）及 sendx/recvx（读写索引）。

环形缓冲区内存布局

type hchan struct {
    qcount   uint           // 当前队列长度（原子访问）
    dataqsiz uint           // 缓冲区大小（0 表示无缓冲）
    buf      unsafe.Pointer // 指向 [dataqsiz]T 的首地址
    elemsize uint16         // 元素大小（字节）
    sendx    uint           // 下一个待发送位置索引（mod dataqsiz）
    recvx    uint           // 下一个待接收位置索引
    recvq    waitq          // 等待接收的 goroutine 队列
    sendq    waitq          // 等待发送的 goroutine 队列
    lock     mutex          // 保护所有字段（除原子字段外）
}

buf 指向连续堆内存块；sendx 与 recvx 通过取模实现环形读写，避免内存拷贝。lock 仅在非原子操作（如入队/出队）时加锁，而 qcount 等关键状态由原子指令维护，兼顾性能与一致性。

内存可见性保障

• 发送操作：写入 buf[sendx] → 原子更新 qcount → sendx++（mod）
• 接收操作：读取 buf[recvx] → 原子更新 qcount → recvx++（mod）
  → 依赖 atomic.StoreUint64 / atomic.LoadUint64 插入内存屏障，确保跨 goroutine 的顺序可见性。

字段	类型	作用
qcount	uint	实时长度，原子读写
buf	unsafe.Pointer	底层元素存储区
recvq/sendq	waitq	阻塞 goroutine 的双向链表

graph TD
    A[goroutine 发送] --> B[检查 qcount < dataqsiz]
    B -->|缓冲未满| C[写入 buf[sendx], sendx++]
    B -->|缓冲已满| D[挂入 sendq 等待]
    C --> E[原子递增 qcount]

3.2 基于channel的生产者-消费者模式工程落地

核心设计原则

• 解耦生产与消费速率：利用 channel 缓冲区平滑流量峰谷
• 明确所有权边界：生产者只写、消费者只读，避免共享状态
• 可控背压：通过有界 channel + select 配合超时/默认分支实现优雅降级

数据同步机制

// 有界缓冲 channel，容量为100，兼顾吞吐与内存安全
jobs := make(chan Task, 100)

// 生产者（goroutine）
go func() {
    for _, t := range tasks {
        select {
        case jobs <- t: // 成功入队
        default:        // 缓冲满时丢弃或告警（依业务策略）
            log.Warn("job dropped: buffer full")
        }
    }
    close(jobs) // 发送完成信号
}()

// 消费者（多协程并发处理）
for i := 0; i < 4; i++ {
    go func() {
        for job := range jobs { // 自动接收直到closed
            process(job)
        }
    }()
}

逻辑分析：jobs 是带缓冲的 channel，容量 100 控制内存占用；select 的 default 分支实现非阻塞写入，避免生产者卡死；close(jobs) 向所有消费者广播终止信号，range 自动退出。参数 Task 需满足可序列化，process() 应具备幂等性。

关键参数对比

参数	推荐值	影响
Buffer Size	64–1024	过小易丢任务，过大增GC压力
Worker Count	CPU × 2	充分利用并行，避免调度开销

graph TD
    A[Producer] -->|send via buffered channel| B[Channel]
    B --> C{Consumer Pool}
    C --> D[Worker 1]
    C --> E[Worker 2]
    C --> F[Worker N]

3.3 select多路复用与超时控制的工业级封装实践

核心封装设计原则

• 隔离系统调用细节，统一错误码与超时语义
• 支持毫秒级精度、可重入、线程安全的事件等待
• 自动管理文件描述符生命周期，避免 fd 泄漏

工业级 SelectManager 示例（C++）

class SelectManager {
public:
    // timeout_ms: 超时毫秒数，-1 表示阻塞，0 表示轮询
    int wait(std::vector<int>& read_fds, std::vector<int>& write_fds, int timeout_ms);
private:
    fd_set m_read_set, m_write_set;
    struct timeval m_tv;
};

timeout_ms 直接映射到 timeval 的 tv_sec/tv_usec 计算；wait() 内部自动重置 fd_set 并校验返回值，屏蔽 EINTR 重试逻辑。

超时精度与可靠性对比

场景	select()	epoll_wait()	封装后 select
1ms 精度	✅（需手动换算）	✅	✅（自动截断补偿）
多次调用稳定性	❌（需重置 fd_set）	✅	✅（内部自动重载）

事件调度流程

graph TD
    A[初始化 fd_set] --> B[注册待监听 fd]
    B --> C[计算 timeout.tv_sec/tv_usec]
    C --> D[调用 select()]
    D --> E{返回 > 0?}
    E -->|是| F[解析就绪 fd 列表]
    E -->|否| G[处理超时/错误]

第四章：并发原语协同与高可用架构构建

4.1 sync包核心原语（Mutex/RWMutex/WaitGroup/Once）在分布式锁中的组合应用

数据同步机制

sync.Mutex 保障本地临界区互斥，但无法跨进程/节点；sync.Once 确保初始化仅执行一次（如连接池构建）；sync.WaitGroup 协调多协程完成状态；sync.RWMutex 在读多写少场景提升并发吞吐。

组合模式示意

var (
    localMu sync.Mutex
    once    sync.Once
    wg      sync.WaitGroup
)

func acquireDistributedLock(key string) bool {
    once.Do(func() { initRedisClient() }) // 全局单次初始化
    localMu.Lock()                        // 防止并发请求争抢本地资源
    defer localMu.Unlock()

    wg.Add(1)
    go func() { defer wg.Done(); tryRedisLock(key) }()
    wg.Wait()
    return isLocked(key)
}

once.Do 确保 Redis 客户端只初始化一次；localMu 保护本地状态（如重试计数器）；wg 同步异步锁尝试结果。注意：此仅为本地协调层，真实锁需依赖 Redis/ETCD 实现。

原语职责对比

原语	作用域	是否可替代分布式锁	典型用途
Mutex	进程内	❌ 否	保护共享变量
RWMutex	进程内	❌ 否	高频读+低频写场景
Once	进程内	❌ 否	幂等初始化
WaitGroup	进程内	❌ 否	协程生命周期同步

graph TD
    A[客户端请求] --> B{本地锁保护}
    B --> C[Once: 初始化连接]
    B --> D[Mutex: 串行化本地操作]
    C & D --> E[调用分布式存储API]
    E --> F[RWMutex: 缓存结果读写]

4.2 context包深度实践：请求链路追踪与优雅关停的全生命周期管理

请求链路追踪：从 context.WithValue 到 trace.SpanContext

使用 context.WithValue 传递 traceID 是常见误区——它破坏类型安全且无法跨服务传播。正确方式是结合 OpenTracing 或 OpenTelemetry 的 context.WithSpanContext：

// 初始化带 traceID 的上下文（OpenTelemetry 示例）
ctx := trace.ContextWithSpanContext(
    context.Background(),
    trace.SpanContextWithTraceID(trace.TraceID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}),
)

该代码将标准化 SpanContext 注入 context，确保 HTTP/GRPC 中间件可自动提取并注入 traceparent 头，实现跨进程链路透传。

优雅关停：CancelFunc 与信号监听协同

服务关停需同时满足：停止新请求接入、等待活跃请求完成、释放资源。

阶段	触发条件	context 行为
接收 SIGTERM	系统信号	调用 root cancel()
拒绝新连接	HTTP Server.Shutdown()	使用 ctx.Done() 控制 listener
请求超时等待	context.WithTimeout	子 context 设定 graceful period

生命周期状态流转

graph TD
    A[Start] --> B[Active Requests]
    B --> C{SIGTERM Received?}
    C -->|Yes| D[Cancel Root Context]
    D --> E[Reject New Requests]
    E --> F[Wait for Active Done]
    F --> G[Release Resources]
    G --> H[Exit]

核心原则：所有 goroutine 必须监听 ctx.Done()，并在 select 中响应取消信号，避免泄漏。

4.3 并发安全的共享状态设计：atomic+unsafe在高频计数器中的极致优化

为什么标准 sync/atomic 不够用？

在每秒千万级增量场景下，atomic.AddUint64 的内存屏障开销成为瓶颈。Go 运行时强制执行 full memory barrier（LOCK XADD），而实际仅需 relaxed ordering。

unsafe.Pointer + atomic.LoadUint64 的零拷贝路径

type FastCounter struct {
    _   [8]byte // cache line padding
    val unsafe.Pointer // *uint64
}

func (c *FastCounter) Inc() {
    // 直接原子写入，绕过 Go runtime 的 barrier 封装
    atomic.AddUint64((*uint64)(c.val), 1)
}

逻辑分析：c.val 指向堆上对齐的 uint64，(*uint64)(c.val) 实现零成本类型转换；atomic.AddUint64 底层仍调用 XADDQ，但避免 interface{} 间接调用与栈复制。参数 c.val 必须保证 8-byte 对齐且生命周期长于计数器实例。

性能对比（百万次操作，纳秒/次）

方式	平均延迟	标准差	缓存失效率
sync/atomic	2.3 ns	±0.4 ns	12.7%
unsafe + atomic	1.1 ns	±0.2 ns	3.9%

关键约束清单

• ✅ 必须使用 runtime.Alloc 或 unsafe.AlignedAlloc 分配对齐内存
• ❌ 禁止在 GC 可达对象中嵌入 unsafe.Pointer 字段（规避 write barrier 绕过）
• ⚠️ 需配合 //go:noescape 注释防止逃逸分析误判

graph TD
    A[goroutine 调用 Inc] --> B[获取 val 指针]
    B --> C[执行 XADDQ 指令]
    C --> D[更新 L1 cache line]
    D --> E[仅触发 store-forwarding，无跨核广播]

4.4 混合并发模型：goroutine+channel+sync+context在微服务网关中的协同架构

微服务网关需同时处理高并发请求、超时控制、跨服务上下文传递与状态同步。单一并发原语难以兼顾可靠性与可维护性，混合模型成为工程最优解。

请求生命周期协同流

func handleRequest(ctx context.Context, req *http.Request) (*http.Response, error) {
    // 派生带超时与取消信号的子上下文
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    // 启动异步鉴权（goroutine） + 结果通道（channel）
    authCh := make(chan bool, 1)
    go func() { authCh <- validateToken(ctx, req.Header.Get("Authorization")) }()

    select {
    case ok := <-authCh:
        if !ok { return nil, errors.New("unauthorized") }
    case <-ctx.Done(): // context 超时或取消
        return nil, ctx.Err()
    }
    return proxyToService(ctx, req) // 透传 context 至下游
}

逻辑分析：context.WithTimeout 提供统一超时与取消传播能力；authCh 容量为1避免 goroutine 泄漏；select 实现非阻塞协作调度，确保网关不因单点延迟雪崩。

核心组件职责矩阵

组件	关键职责	典型使用场景
goroutine	并发执行独立任务	鉴权、日志上报、指标采集
channel	安全传递结果/事件，实现解耦	异步校验结果、熔断状态通知
sync.Mutex	保护共享状态（如连接池计数器）	限流器令牌桶原子更新
context	跨协程传递截止时间、取消信号、值	请求链路追踪ID、租户上下文透传

graph TD A[HTTP Request] –> B{goroutine: parse & validate} B –> C[channel: auth result] C –> D{select on channel + context.Done} D –>|Success| E[goroutine: route & proxy] D –>|Timeout/Cancel| F[return error] E –> G[context: traceID, timeout]

第五章：从理论到生产的Go并发演进之路

并发模型的生产校验：订单履约系统的三次重构

某电商履约平台初期采用 goroutine + channel 的朴素模型处理每秒3000+订单分发，但上线后频繁出现 channel 阻塞超时。根源在于未对 channel 容量做压测验证——默认无缓冲 channel 在下游处理延迟突增时形成级联阻塞。团队通过 pprof 分析发现 62% 的 goroutine 处于 chan send 等待状态。最终引入带缓冲 channel（容量=200）并配合 select 超时控制，将平均延迟从 840ms 降至 112ms。

上下文取消的实战陷阱：微服务链路中的僵尸goroutine

在支付网关中，一个未正确传播 context.Context 的异步日志上报逻辑导致每笔失败交易残留 3 个 goroutine。持续运行 72 小时后累积 12 万+ goroutine，内存泄漏达 4.2GB。修复方案采用 context.WithTimeout 统一注入，并强制所有 I/O 操作接受 context 参数：

func logAsync(ctx context.Context, event LogEvent) {
    select {
    case <-time.After(5 * time.Second):
        return // 超时退出
    case <-ctx.Done():
        return // 取消退出
    }
}

并发安全的数据结构选型对比

场景	sync.Map	RWMutex + map	atomic.Value
高频读+低频写	✅ 原生支持	⚠️ 读锁竞争高	❌ 不支持复杂类型
写操作需原子更新	❌ 无 CAS 接口	✅ 可控	✅ 支持指针替换
内存占用敏感	⚠️ 额外哈希表开销	✅ 最小化	✅ 零额外开销

实际案例：用户会话缓存改用 sync.Map 后，QPS 提升 37%，但 GC 压力增加 18%，最终采用 RWMutex + map[string]*Session 平衡性能与内存。

生产环境的并发监控体系

部署 expvar 暴露 goroutine 数量、channel 状态等指标，并接入 Prometheus 报警规则：

• go_goroutines > 5000 触发 P2 告警
• go_chan_send_blocked_seconds_sum > 10 触发 P1 告警
  同时在关键路径嵌入 runtime.ReadMemStats 快照，当并发任务数超过阈值时自动 dump goroutine stack：

graph LR
A[HTTP 请求] --> B{并发数 > 1000?}
B -- 是 --> C[触发 runtime.Stack]
B -- 否 --> D[正常处理]
C --> E[写入 /tmp/goroutine_20240515.log]
E --> F[ELK 自动解析异常模式]

跨服务调用的并发治理

订单创建服务调用库存、风控、营销三个下游，原始代码使用 sync.WaitGroup 并发请求，但缺乏熔断机制。改造后引入 errgroup.Group 统一错误传播，并设置全局超时：

g, ctx := errgroup.WithContext(context.WithTimeout(ctx, 800*time.Millisecond))
g.Go(func() error { return checkInventory(ctx) })
g.Go(func() error { return runRiskControl(ctx) })
g.Go(func() error { return applyPromotion(ctx) })
if err := g.Wait(); err != nil {
    metrics.Inc("order_create_failed", "timeout")
}

混沌工程验证下的并发韧性

在预发环境注入随机网络延迟（200~1200ms）、CPU 限频（限制为 1 核），发现 time.AfterFunc 创建的定时器未绑定 context 导致资源泄漏。修复后所有定时器均通过 time.AfterFunc 替换为 time.NewTimer 并在 defer 中显式 Stop。

持续交付中的并发回归测试

构建专用并发测试框架，对核心接口执行三类压力测试：

• 固定并发数（100/500/2000 goroutine）
• 指数增长负载（每秒新增 50 goroutine 持续 60 秒）
• 混合场景（80% 读 + 20% 写 + 5% 错误注入）
  测试报告自动生成 goroutine 增长曲线、channel 阻塞率热力图、GC pause 时间分布直方图。