高级

高并发设计

High Concurrency Design

支撑百万级 QPS，掌握缓存、异步、分库分表等性能优化策略。

1并发性能指标

**核心指标**： - **QPS (Queries Per Second)**：每秒查询数 - **TPS (Transactions Per Second)**：每秒事务数 - **RT (Response Time)**：响应时间 - **Throughput**：吞吐量 **Go 的并发优势**： - Goroutine 轻量级（初始 2KB 栈） - GMP 调度模型高效 - Channel 原生支持 CSP 并发模型

2多级缓存架构

高并发系统的缓存分层：

example.go

1// 多级缓存实现
2type MultiLevelCache struct {
3    local  *LocalCache    // L1: 本地缓存
4    redis  *redis.Client  // L2: Redis
5    db     *sql.DB        // L3: 数据库
6}
7 
8func (c *MultiLevelCache) Get(ctx context.Context, key string) ([]byte, error) {
9    // L1: 本地缓存
10    if val, ok := c.local.Get(key); ok {
11        return val, nil
12    }
13 
14    // L2: Redis
15    val, err := c.redis.Get(ctx, key).Bytes()
16    if err == nil {
17        c.local.Set(key, val, time.Minute)
18        return val, nil
19    }
20 
21    // L3: 数据库 (使用 singleflight 防止缓存击穿)
22    val, err, _ = c.group.Do(key, func() (interface{}, error) {
23        data, err := c.loadFromDB(ctx, key)
24        if err != nil {
25            return nil, err
26        }
27        // 回填缓存
28        c.redis.Set(ctx, key, data, time.Hour)
29        c.local.Set(key, data, time.Minute)
30        return data, nil
31    })
32 
33    return val.([]byte), err
34}

3异步处理与消息队列

削峰填谷，提升系统吞吐：

example.go

1// Worker Pool 模式
2type WorkerPool struct {
3    tasks   chan Task
4    results chan Result
5    workers int
6}
7 
8func NewWorkerPool(workers, queueSize int) *WorkerPool {
9    pool := &WorkerPool{
10        tasks:   make(chan Task, queueSize),
11        results: make(chan Result, queueSize),
12        workers: workers,
13    }
14    pool.Start()
15    return pool
16}
17 
18func (p *WorkerPool) Start() {
19    for i := 0; i < p.workers; i++ {
20        go func(workerID int) {
21            for task := range p.tasks {
22                result := task.Execute()
23                p.results <- result
24            }
25        }(i)
26    }
27}
28 
29// Web3 场景：批量处理链上事件
30func (p *WorkerPool) ProcessEvents(events []Event) {
31    for _, event := range events {
32        p.tasks <- Task{Event: event}
33    }
34}

核心要点

•读多写少用缓存，写多读少用队列
•热点数据本地缓存 + 分布式缓存
•使用 singleflight 防止缓存击穿
•异步处理非关键路径

真实案例

→以太坊节点：LevelDB 本地缓存
→NFT 市场：Redis 缓存 + CDN
→DEX：内存撮合 + 异步上链

高可用架构分布式系统

1并发性能指标

2多级缓存架构

高并发系统的缓存分层：

example.go

1// 多级缓存实现
2type MultiLevelCache struct {
3    local  *LocalCache    // L1: 本地缓存
4    redis  *redis.Client  // L2: Redis
5    db     *sql.DB        // L3: 数据库
6}
7 
8func (c *MultiLevelCache) Get(ctx context.Context, key string) ([]byte, error) {
9    // L1: 本地缓存
10    if val, ok := c.local.Get(key); ok {
11        return val, nil
12    }
13 
14    // L2: Redis
15    val, err := c.redis.Get(ctx, key).Bytes()
16    if err == nil {
17        c.local.Set(key, val, time.Minute)
18        return val, nil
19    }
20 
21    // L3: 数据库 (使用 singleflight 防止缓存击穿)
22    val, err, _ = c.group.Do(key, func() (interface{}, error) {
23        data, err := c.loadFromDB(ctx, key)
24        if err != nil {
25            return nil, err
26        }
27        // 回填缓存
28        c.redis.Set(ctx, key, data, time.Hour)
29        c.local.Set(key, data, time.Minute)
30        return data, nil
31    })
32 
33    return val.([]byte), err
34}

3异步处理与消息队列

削峰填谷，提升系统吞吐：

example.go

1// Worker Pool 模式
2type WorkerPool struct {
3    tasks   chan Task
4    results chan Result
5    workers int
6}
7 
8func NewWorkerPool(workers, queueSize int) *WorkerPool {
9    pool := &WorkerPool{
10        tasks:   make(chan Task, queueSize),
11        results: make(chan Result, queueSize),
12        workers: workers,
13    }
14    pool.Start()
15    return pool
16}
17 
18func (p *WorkerPool) Start() {
19    for i := 0; i < p.workers; i++ {
20        go func(workerID int) {
21            for task := range p.tasks {
22                result := task.Execute()
23                p.results <- result
24            }
25        }(i)
26    }
27}
28 
29// Web3 场景：批量处理链上事件
30func (p *WorkerPool) ProcessEvents(events []Event) {
31    for _, event := range events {
32        p.tasks <- Task{Event: event}
33    }
34}