系统设计

1. 高并发系统设计

1.1 垂直扩展 (Scale Up)

1.2 水平扩展 (Scale Out)

                    ┌─────────────┐
                    │   Nginx     │
                    │  负载均衡   │
                    └──────┬──────┘
                           │
            ┌──────────────┼──────────────┐
            │              │              │
       ┌────▼────┐    ┌────▼────┐    ┌────▼────┐
       │ Server1 │    │ Server2 │    │ Server3 │
       └─────────┘    └─────────┘    └─────────┘

1.3 核心策略

2. 高可用设计

2.1 限流 (Rate Limiting)

// 令牌桶算法
public class TokenBucket {
    private int capacity;        // 桶容量
    private int tokens;          // 当前令牌数
    private double refillRate;   //  refill rate

    public boolean tryAcquire(int permits) {
        if (tokens >= permits) {
            tokens -= permits;
            return true;
        }
        return false;
    }
}

2.2 熔断器 (Circuit Breaker)

CLOSED (正常) → 失败率超阈值 → OPEN (熔断) →  半开 → OPEN/CLOSED

// Resilience4j 熔断示例
@CircuitBreaker(name = "backend", fallbackMethod = "fallback")
public String callService() {
    return restTemplate.getForObject("http://service/api", String.class);
}

public String fallback(Exception e) {
    return "服务暂时不可用，请稍后重试";
}

2.3 降级 (Degradation)

• 读服务降级：返回缓存数据/默认值
• 写服务降级：延迟写入/本地队列
• 非核心功能关闭：推荐、统计等

2.4 多活架构

┌─────────────┐    ┌─────────────┐
│   机房 A     │    │   机房 B     │
│  (主站)     │    │  (备站)     │
│  写+读      │    │  读         │
└─────────────┘    └─────────────┘

3. 缓存设计

3.1 缓存策略

3.2 缓存问题

缓存穿透

// 布隆过滤器或空值缓存
public String get(String key) {
    String value = redis.get(key);
    if (value == null) {
        value = db.query(key);
        if (value == null) {
            redis.setex(key, 60, "");  // 空值缓存，避免穿透
        } else {
            redis.setex(key, 3600, value);
        }
    }
    return value;
}

缓存击穿

// 互斥锁 + 永不过期
public String get(String key) {
    String value = redis.get(key);
    if (value == null) {
        synchronized(this) {
            value = redis.get(key);
            if (value == null) {
                value = db.query(key);
                redis.set(key, value, 0);  // 永不过期，手动控制
            }
        }
    }
    return value;
}

缓存雪崩

// 过期时间 + 随机偏移
public void set(String key, String value, long expire) {
    // 添加随机偏移，避免同时过期
    long randomOffset = ThreadLocalRandom.current().nextLong(0, expire / 10);
    redis.setex(key, expire + randomOffset, value);
}

3.3 Redis 集群

• 主从复制：读写分离
• Sentinel：故障自动切换
• Cluster：数据分片

4. 消息队列

4.1 常用场景

4.2 Kafka vs RabbitMQ

4.3 消息可靠性

// Kafka 可靠生产
properties.put("acks", "all");        // 等待所有副本确认
properties.put("retries", 3);         // 重试3次
properties.put("enable.idempotence", true);  // 幂等生产

// 消费端确认
consumer.commitSync();  // 手动提交offset

4.4 消息顺序

// 确保同一Key的消息发送到同一Partition
producer.send(new ProducerRecord<>("topic", "user_id", message));

// 消费端按Partition顺序处理
while (true) {
    ConsumerRecords<String, String> records = consumer.poll();
    for (ConsumerRecord<String, String> record : records) {
        // 按顺序处理
    }
}

5. 数据库设计

5.1 读写分离

写 → 主库
读 → 从库

5.2 分库分表

垂直拆分

用户库：用户基本信息
订单库：订单相关表
商品库：商品相关表

水平拆分

5.3 分页问题

-- 深度分页优化：游标分页
SELECT * FROM orders
WHERE id > last_max_id
ORDER BY id
LIMIT 20;

-- 或者使用ElasticSearch

5.4 索引设计

6. 微服务架构

6.1 服务拆分

6.2 服务治理

注册中心：Nacos / Consul / Eureka
配置中心：Apollo / Nacos Config
服务网关：Kong / Spring Cloud Gateway
服务监控：Prometheus + Grafana
链路追踪：SkyWalking / Zipkin

6.3 服务间通信

7. 分布式 ID 生成

7.1 方案对比

7.2 Snowflake 算法

┌─────────┬────────┬────────┬────────┬────────┬────────┐
│ 符号位   │  时间戳  │ 机器ID │ 序列号  │        │        │
│  1 bit  │ 41 bit │ 10 bit│ 12 bit│        │        │
└─────────┴────────┴────────┴────────┴────────┴────────┘

- 时间戳：可使用69年
- 机器ID：1024个节点
- 序列号：每毫秒4096个ID

public class SnowflakeIdGenerator {
    private final long workerId;
    private final long epoch = 1609459200000L;  // 2021-01-01
    private long sequence = 0L;

    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis() - epoch;
        sequence = (sequence + 1) & 4095;  // 毫秒内序列溢出归零
        return (timestamp << 22) | (workerId << 12) | sequence;
    }
}

8. 接口设计原则

8.1 RESTful API

8.2 统一响应格式

{
    "code": 200,
    "message": "success",
    "data": {
        "id": 1,
        "name": "张三"
    },
    "timestamp": "2024-01-15T10:30:00Z"
}

8.3 幂等性设计

// 幂等Token
public String createToken() {
    return UUID.randomUUID().toString();
}

// 提交时验证
public boolean submitOrder(String idempotentKey, Order order) {
    if (redis.exists("order:token:" + idempotentKey)) {
        return false;  // 已处理
    }
    // 处理订单
    redis.setex("order:token:" + idempotentKey, 86400, "1");
    return true;
}

9. 系统设计步骤

9.1 分析需求

1. 功能需求：核心功能有哪些
2. 非功能需求：QPS、延迟、可用性、数据量
3. 约束条件：技术栈、团队能力

9.2 设计要点

1. 高并发 → 缓存 + 异步 + 负载均衡
2. 高可用 → 限流 + 熔断 + 降级 + 多活
3. 数据一致性 → 最终一致 vs 强一致
4. 扩展性 → 水平扩展优先于垂直扩展

9.3 常见系统

参考资料

• 系统设计面试题
• DDD 领域驱动设计
• 高并发系统设计40问