面试题集锦:IO/CPU/GMP/CSP/MQ 串讲

面试题集锦:IO/CPU/GMP/CSP/MQ 串讲

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


本文档系统整理 Go 高并发、消息队列、Kafka 等核心面试知识,适合快速复习和面试准备。

目录

  1. I/O 密集型 vs CPU 密集型
  2. GMP 模型详解
  3. Hertz 高性能原理
  4. CSP vs 共享内存
  5. Go vs Java 高并发方案对比
  6. RocketMQ vs Kafka 对比
  7. Kafka 高吞吐量的代价
  8. 信号量许可获取模式

1. I/O 密集型 vs CPU 密集型

TL;DR

类型瓶颈CPU 利用率典型场景
网络 I/O 密集型等待网络响应< 30%REST API、消息推送、Feed 流
文件 I/O 密集型等待磁盘读写波动大日志写入、音视频转码
CPU 密集型纯计算接近 100%加密解密、图像处理、复杂数学运算

业务例子

网络 I/O 密集型(你的项目场景):

// 典型的 API Handler - 等待下游 RPC/DB 响应
func (s *UserHandler) GetUser(ctx context.Context, req *user.GetRequest) (*user.GetResponse, error) {
    user, err := s.userService.GetUser(ctx, req.UserID)  // 等待 Redis/MongoDB
    if err != nil {
        return nil, err
    }
    return &user, nil  // 大部分时间在等 I/O
}

文件 I/O 密集型:

// 日志收集服务 - 大量写磁盘
func WriteLogs(filename string, logs []LogEntry) {
    for _, log := range logs {
        file.Write(log)  // 磁盘 I/O 等待
    }
}

CPU 密集型:

// 视频转码、图片压缩
func EncodeVideo(video []byte) []byte {
    // H.264 编码 - 纯 CPU 计算
    return h264Encode(video)
}

实战判断方法

# 查看 CPU 利用率
top
 
# 如果 CPU% 低但负载高 → I/O 密集型
# 如果 CPU% 高 → CPU 密集型
 
# Go 项目用 pprof 看 CPU 分布
go tool pprof -http=:8080 http://localhost:6060/debug/pprof/profile?seconds=30

GOMAXPROCS 设置建议

// CPU 密集型:= CPU 核心数(避免过度调度)
GOMAXPROCS(runtime.NumCPU())
 
// I/O 密集型:可以 2-4 倍 CPU 核心数
// 因为 I/O 等待时不占 CPU
GOMAXPROCS(runtime.NumCPU() * 2)

面试追问

Q: 如何确定当前服务是哪种类型?

A: 用 pprof 看 CPU profile,或者监控 iostat/netstat。I/O 密集型服务 CPU 使用率通常 < 30%。


2. GMP 模型详解

详细内容请参考:08-gmp-scheduler-and-memory-management.md

核心要点(3 分钟速记)

G (Goroutine) ~2KB  ──→  P (Processor)  ──→  M (Machine/OS线程)
     任务实体              逻辑处理器            实际执行者
   (可创建数十万)        (数量=GOMAXPROCS)
组件含义类比
G (Goroutine)轻量级任务单位共享单车
P (Processor)逻辑执行器,有本地队列停车位
M (Machine)OS 线程,实际 CPU 执行者骑手

关键优势

维度Go GoroutineJava Thread
栈大小2KB(可增长到 1GB)1MB(固定)
创建成本~200ns~1-2ms
切换成本~200-300ns~1000-2000ns
调度方式用户态 GMP纯内核调度
最大并发轻松数十万受内存限制,通常数百

调度流程图

创建 Goroutine
       │
       ▼
进入 P 的本地队列 (LRQ)
       │
       ▼
被 P 调度到 M 上执行
       │
       ├──→ 正常执行完毕 → 销毁
       │
       ├──→ 阻塞等待(Channel/系统调用)
       │         │
       │         ▼
       │     与 M 解绑,进入等待队列
       │         │
       │         ▼
       │     唤醒后重新进入队列
       │
       └──→ 时间片用完
                 │
                 ▼
             放回队列尾部

阻塞处理

场景 1:系统调用阻塞

G 调用阻塞系统调用时:
1. M 释放 P(P 回到空闲队列)
2. G 绑定到 M,继续等待
3. 调度器创建/唤醒新 M,继续执行其他 G

场景 2:Channel 阻塞

ch := make(chan int)
<-ch  // G 阻塞
 
当 G 阻塞在 Channel 时:
1. G 从 M 解绑,进入 Channel 的等待队列
2. M 继续执行其他 G
3. 另一个 G 往 Channel 写数据时,唤醒等待的 G

队列窃取 (Work Stealing)

当 P1 的 LRQ 为空时:
1. 先尝试从 GRQ 获取
2. GRQ 也为空?
3. 随机偷另一个 P 的 LRQ 的一半

好处:负载均衡 + 保持所有核心繁忙

业务场景举例

// 场景:消息推送服务 - 数十万长连接
func (s *PusherService) PushLoop() {
    for {
        conn := s.getConnection()  // 阻塞等待新连接
        go s.handleConnection(conn) // 轻量创建数十万个 goroutine
    }
}
// 每个长连接 = 1 个 goroutine (~2KB)
// Java 如果用线程 = 1MB × 10万 = 100GB 内存!

3. Hertz 高性能原理

详细内容请参考:06-hertz-netpoll-and-websocket.md

TL;DR

Hertz 高性能 = Netpoll(自研网络库)+ 多路复用 + 零拷贝

3.1 基于 Netpoll 的事件驱动

传统 select/poll:                    Netpoll(Epoll/kqueue):
┌──────────────────┐                ┌──────────────────┐
│  每次调用都要遍历 │                │  只遍历活跃连接   │
│  所有 FD          │                │  时间复杂度 O(1)  │
│  O(n)             │                └──────────────────┘
└──────────────────┘

Netpoll 是字节跳动自研的网络库,核心基于 epoll (Linux) / kqueue (macOS):

  • 百万级连接:只关注活跃连接,不遍历所有 FD
  • 边缘触发:减少无效通知

3.2 高效的事件循环

// Hertz 事件循环伪代码
func (h *Server) eventLoop() {
    for {
        // 1. 等待活跃事件(epoll_wait)
        events := epoll.Wait(...)
 
        // 2. 分发处理
        for _, event := range events {
            switch event.Type {
            case EventRead:
                // 读就绪 → 读取请求
                req := readRequest(event.FD)
                // 投放到 worker pool
                pool.Submit(func() {
                    handler.ServeHTTP(req)
                })
            case EventWrite:
                // 写就绪 → 发送响应
                sendResponse(event.FD)
            }
        }
    }
}

关键设计:

  • 读写分离:读事件投放到 Worker Pool,并发处理
  • 惊群效应优化:多 Accept 协程竞争,但只在必要时唤醒

3.3 零拷贝请求处理

传统 HTTP Server:                    Hertz 零拷贝:
┌─────────────────────────────┐      ┌─────────────────────────────┐
│  [网卡] → 内核缓冲区         │      │  [网卡] → 内核缓冲区         │
│         → 用户缓冲区         │      │           ╲                 │
│         → 业务处理           │      │            ╲ (直接处理)      │
│         → 用户缓冲区         │      │             业务处理         │
│         → Socket 缓冲区      │      │             ↓               │
│         → [网卡]             │      │        不经过用户空间拷贝     │
└─────────────────────────────┘      └─────────────────────────────┘
4 次拷贝(2 次 DMA + 2 次 CPU 拷贝)      2 次拷贝(减少 CPU 拷贝)

实现方式:

  • 使用 sendfile 系统调用
  • 请求解析时直接引用内核缓冲区的数据,不做额外拷贝
  • 响应直接通过 writev 发送

3.4 业界对比

框架QPS (单机)延迟 P99特点
Hertz30万+< 5ms字节自研,优化极致
Gin10万< 10ms生态好,简单易用
Fasthttp20万< 8ms优化但 API 不兼容 http.Handler

4. CSP vs 共享内存

详细内容请参考:07-go-shared-memory-vs-csp.md

TL;DR

CSP(Communicating Sequential Processes):通过通信来共享内存 共享内存:通过锁等同步机制共享变量

Go 的核心理念:不要通过共享内存通信,要通过通信来共享内存

两种方式对比

方式 1:共享内存(Shared Memory)

// ❌ 共享内存方式 - 容易出 Bug
type Counter struct {
    mu    sync.Mutex
    value int
}
 
func (c *Counter) Increment() {
    c.mu.Lock()
    c.value++  // 临界区操作
    c.mu.Unlock()
}
 
// 多个 goroutine 并发访问
for i := 0; i < 1000; i++ {
    go c.Increment()
}

问题:

  • 竞态条件(Race Condition)
  • 死锁风险
  • 锁争用导致性能瓶颈

方式 2:通信(Channel)

// ✅ Channel 方式 - 安全并发
func producer(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i  // 发送数据
    }
    close(ch)
}
 
func consumer(ch <-chan int) {
    for v := range ch {
        fmt.Println(v)  // 接收数据
    }
}
 
func main() {
    ch := make(chan int, 100)  // 有缓冲 Channel
    go producer(ch)
    go consumer(ch)
    time.Sleep(time.Second)
}

适用场景

场景推荐方式原因
简单计数器共享内存 + MutexChannel 过度设计
任务分发Channel解耦生产者/消费者
事件通知Channel / sync.Cond避免轮询
全局配置sync.Map 或配置中心读多写少
连接池共享内存 + Mutex需要随机访问

Java 对应实现

Java 没有内置 Channel,但可以用:

// 方式 1:BlockingQueue(类似 Channel)
BlockingQueue<Task> queue = new LinkedBlockingQueue<>(100);
queue.put(task);  // 发送
Task t = queue.take();  // 接收
 
// 方式 2:Akka Actor(真正的 CSP)
ActorRef worker = system.actorOf(Props.create(Worker.class));
worker.tell(task, getSelf());  // 发送消息

5. Go vs Java 高并发方案对比

详细内容请参考:

TL;DR

方案GoJava
原生模型Goroutine + ChannelThread + synchronized
轻量线程GMP 调度(~2KB 栈)Project Loom(虚拟线程 ~1KB)
响应式-WebFlux / RxJava
Actor 模型-Akka

5.1 Go 的方案:Goroutine + Channel

// Go 原生并发 - 简单直接
func main() {
    // 创建 10 万个 goroutine
    for i := 0; i < 100000; i++ {
        go func(id int) {
            time.Sleep(time.Second)
            fmt.Println(id)
        }(i)
    }
    time.Sleep(2 * time.Second)
}

5.2 Java 的方案

Project Loom(虚拟线程,Java 21+)

// 看起来像 Thread,但底层是协程
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 100_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            System.out.println(i);
            return i;
        });
    });
}
// 10 万虚拟线程 = ~100MB 内存(而不是 10 万 × 1MB)

Loom vs Go Goroutine:

维度Go GoroutineJava 虚拟线程
栈大小2KB(可增长)1KB(可增长)
调度GMP 用户态调度ForkJoinPool 或专用调度器
Channel原生支持需要手动实现或用 Flow
成熟度成熟(Go 1.x)较新(Java 21+)

Reactive 编程(WebFlux)

// 非阻塞响应式
@RestController
public class UserController {
    @GetMapping("/user/{id}")
    public Mono<User> getUser(@PathVariable Long id) {
        return userService.findById(id)  // 返回 Mono<User>
                   .subscribeOn(Schedulers.boundedElastic());
    }
}
 
// 链式调用
userService.findById(id)
    .map(this::toDTO)
    .flatMap(this::enrichWithPermissions)
    .subscribe(System.out::println);

特点:

  • 背压(Backpressure)支持
  • 适合 I/O 密集型
  • 学习曲线陡

Actor 模型(Akka)

// Actor 是状态和行为的封装,通信通过消息
public class Worker extends AbstractActor {
    @Override
    public Receive createReceive() {
        return receiveBuilder()
            .match(Task.class, this::processTask)
            .build();
    }
 
    private void processTask(Task t) {
        // 处理任务
        getSender().tell(new Result(t.getId()), getSelf());
    }
}
 
// 发送消息
system.actorOf(Props.create(Worker.class)).tell(new Task(), getSelf());

特点:

  • 天然分布式
  • 容错(Supervision 树)
  • 适合复杂并发状态

对比总结

维度GoJava (Loom)Java (Reactive)Akka
并发模型CSP直接 APIReactive StreamActor
学习曲线低低高中高
分布式支持弱弱中强
生态成熟度成熟新兴成熟成熟
适用场景微服务、I/O轻量替换 Thread高并发 I/O复杂状态

6. RocketMQ vs Kafka 对比

详细内容请参考:

核心对比

维度KafkaRocketMQ
定位日志收集、流处理事务消息、电商订单
延迟毫秒级微秒级(延迟消息原生支持)
事务弱(幂等 Producer)强(事务消息)
延迟消息需插件原生支持
顺序消息单 Partition 有序单队列有序
单队列性能百万级 QPS十万级 QPS

事务消息对比

Kafka 事务(弱):

// 只能保证 Producer 端幂等
producer := &KafkaProducer{
    enableIdempotence: true,  // 开启幂等
    transactionID: "order-tx",  // 但不是真正的事务消息
}

RocketMQ 事务消息(强):

// 事务消息:本地事务 + 消息投递原子性
@Transactional
public void placeOrder(Order order) {
    // 1. 本地事务(扣库存)
    orderService.create(order);
    inventoryService.deduct(order.getItemId());
 
    // 2. 发送半消息(RocketMQ 保证)
    transactionMQProducer.sendMessageInTransaction(order,
        (msg, arg) -> {
            // 本地事务执行
            return LocalTransactionState.COMMIT_MESSAGE;
        }, null);
}

RocketMQ 事务消息流程:

Producer 发送半消息
       │
       ▼
Broker 保存消息(不可消费)
       │
       ▼
Producer 执行本地事务
       │
       ├── 成功 → 发送确认 → 消息可消费
       │
       └── 失败 → 回滚 → 消息丢弃

选型决策树

需要事务消息(订单、支付)?──→ RocketMQ
         │
         ├── 需要延迟/定时消息?──→ RocketMQ
         │
         └── 日志收集/大数据?──→ Kafka
                   │
                   └── 高吞吐场景?──→ Kafka

7. Kafka 高吞吐量的代价

详细内容请参考:KAFKA_PRODUCTION_ARCHITECTURE_IM_TRADING.md

TL;DR

Kafka 快 = 顺序写 + 零拷贝 + 批量处理,但代价是:消息查找慢、内存压力大、运维复杂。

代价详解

代价 1:消息查找依赖索引,延迟增加

传统数据库:              Kafka:
┌──────────────┐        ┌──────────────┐
│ B+Tree 索引   │        │  顺序追加写   │
│ 随机读写      │        │  无索引       │
│ O(log n)      │        │  O(1)        │
└──────────────┘        └──────────────┘
查单条:快               查单条:需遍历

问题:无法按消息 ID 直接查找,必须用 offset + 顺序扫描

代价 2:页缓存内存压力大

Kafka 写入:先写 Page Cache → 异步刷盘
           ↓
如果机器内存 64GB,Page Cache 可能占用 32GB+
           ↓
其他进程内存紧张

代价 3:磁盘 I/O 争用

Kafka 顺序写 600MB/s
       +
其他进程磁盘 I/O
       =
磁盘头争用,性能下降

代价 4:Rebalance 停顿

Consumer 加入/离开
       ↓
Stop The World(停止消费)
       ↓
重新分配分区(可能 30 秒停顿)
       ↓
影响实时性要求高的业务

代价 5:运维复杂度

问题影响
Partition 数量固定增加 Partition 需要 reassign
副本同步延迟可能丢消息(如果配置不当)
Controller 单点ZooKeeper/raft controller 挂了影响整个集群
消息保留策略磁盘满 / 清理不及时

什么时候不用 Kafka?

  • 需要事务消息 → 用 RocketMQ
  • 消息量小(< 1万/秒)→ 用 RabbitMQ
  • 需要复杂查询 → 用数据库
  • 延迟敏感(< 10ms)→ 考虑 RocketMQ 或 Pulsar

8. 信号量许可获取模式

详细内容请参考:03-go-semaphore-vs-java-semaphore.md

问题分析

代码模式:

for {
    // 1. 串行获取许可
    sem.Acquire(ctx, 1)
 
    // 2. 并发处理
    go func() {
        defer sem.Release(1)
        process()
    }()
}

是否合理?

结论:合理,但有优化空间。

为什么合理?

串行获取许可 ──→ 保证不会超过并发上限
     │
     ▼
并发处理    ──→ 充分利用多核
  • 信号量控制并发数:防止资源耗尽
  • 串行获取:确保不超限
  • 并发处理:实际 work 是并发的

潜在问题

问题场景
许可不足时阻塞高负载下请求等待
goroutine 泄漏处理慢 + 许可少 = 积压
资源争用大量 goroutine 等待同一信号量

优化方案

方案 1:增加预获取(适合突发流量)

// 一次获取多个许可,减少竞争
for {
    sem.Acquire(ctx, batchSize)  // 批量获取
 
    for i := 0; i < batchSize; i++ {
        go func() {
            defer sem.Release(1)
            process()
        }()
    }
}

方案 2:Worker Pool(适合稳定流量)

// 固定数量 worker,真正串行处理
pool := make(chan struct{}, 10)  // 10 个并发 worker
 
for task := range tasks {
    pool <- struct{}{}  // 获取许可
    go func(t Task) {
        defer func() { <-pool }()  // 释放许可
        process(t)
    }(task)
}

方案 3:Context + Timeout(适合有超时场景)

for {
    // 带超时的获取
    err := sem.Acquire(ctx, 1)
    if err != nil {
        return  // context 取消或超时
    }
 
    go func() {
        defer sem.Release(1)
        process()
    }()
}

实际项目中的建议

参考项目中的 Worker Pool 实现:

// 项目中的 Kafka Worker Pool
// 已经是成熟的模式:预分配 worker,并发消费
 
workerPool := make([]Worker, cfg.WorkerCount)
for i := range workerPool {
    go workerPool[i].Run(ctx)  // 预分配,不动态创建
}

原则:

  1. 高并发 I/O 场景 → 串行获取许可 + 并发处理(当前模式)
  2. CPU 密集型场景 → 直接用 Worker Pool,避免 goroutine 切换开销
  3. 突发流量 → 用信号量 + 批量获取 + 超时控制

关联文档


一图总结

┌─────────────────────────────────────────────────────────────────┐
│                    Go 高并发技术栈                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │  I/O 密集型  │    │  CPU 密集型  │    │  混合型     │         │
│  │  GOMAXPROCS │    │  GOMAXPROCS │    │  分析瓶颈   │         │
│  │  > CPU核数  │    │  = CPU核数  │    │  按需调整   │         │
│  └──────┬──────┘    └──────┬──────┘    └──────┬──────┘         │
│         │                  │                  │                 │
│         ▼                  ▼                  ▼                 │
│  ┌─────────────────────────────────────────────────┐           │
│  │              GMP 调度器                           │           │
│  │   G ──→ P ──→ M                                  │           │
│  │  (2KB)  (逻辑CPU) (OS线程)                       │           │
│  └────────────────────┬────────────────────────────┘           │
│                       │                                        │
│         ┌─────────────┼─────────────┐                         │
│         ▼             ▼             ▼                         │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐                   │
│  │  Channel  │  │  Mutex    │  │ Semaphore │                   │
│  │  (CSP)    │  │  (共享内存)│  │  (并发控制) │                   │
│  └───────────┘  └───────────┘  └───────────┘                   │
│                                                                │
│  ┌─────────────────────────────────────────────────┐           │
│  │              Hertz HTTP Server                   │           │
│  │  Netpoll + 事件循环 + 零拷贝                     │           │
│  └────────────────────┬────────────────────────────┘           │
│                       │                                        │
│         ┌─────────────┴─────────────┐                         │
│         ▼                           ▼                         │
│  ┌───────────┐               ┌───────────┐                    │
│  │   Kafka   │               │ RocketMQ  │                    │
│  │  高吞吐    │               │ 事务消息   │                    │
│  └───────────┘               └───────────┘                    │
└─────────────────────────────────────────────────────────────────┘