CPU 密集型 vs I/O 密集型

🎯 核心概念：什么是 CPU 密集 / I/O 密集

计算机程序运行时，主要消耗两种资源：CPU（处理器）和 I/O（输入输出）。根据瓶颈在哪，程序被分为两类：

📋 典型场景速查

⚡ 为什么区分它们如此重要？

因为 两种类型需要完全不同的优化策略。用错策略会让程序效率反而下降，甚至出现「多线程比单线程还慢」的反直觉结果。

🔴 CPU 密集型 — 应该怎么处理？

核心原则：不要创建比 CPU 核心数更多的计算线程

推荐方案

为什么线程数 = 核心数是最优的？

代码示例

Python 中 CPU 密集任务的正确定姿：

# ❌ 错误：Python 多线程对 CPU 密集任务无效（GIL 限制）
from concurrent.futures import ThreadPoolExecutor

def heavy_compute(n):
    return sum(i * i for i in range(n))

# ThreadPoolExecutor — 被 GIL 限制，实际还是单核在跑
with ThreadPoolExecutor(max_workers=8) as executor:
    results = executor.map(heavy_compute, [10_000_000] * 8)

# ✅ 正确：用 ProcessPoolExecutor 绕过 GIL
from concurrent.futures import ProcessPoolExecutor
import os

cpu_count = os.cpu_count()

with ProcessPoolExecutor(max_workers=cpu_count) as executor:
    results = executor.map(heavy_compute, [10_000_000] * 8)
    # 真正利用所有核心并行计算

Go / Rust 中 CPU 密集任务（无 GIL，多线程有效）：

// Go：用 runtime.NumCPU() 控制 goroutine 数量
package main

import (
    "runtime"
    "sync"
)

func main() {
    numCPU := runtime.NumCPU()           // 获取 CPU 核心数
    runtime.GOMAXPROCS(numCPU)           // 设置最大并行度

    var wg sync.WaitGroup
    tasks := make(chan int, numCPU)

    for i := 0; i < numCPU; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for task := range tasks {
                heavyCompute(task)         // CPU 密集计算
            }
        }()
    }
    // 分发任务...
    wg.Wait()
}

🔵 I/O 密集型 — 应该怎么处理？

核心原则：不要让 CPU 闲着等 I/O，让等待时间「重叠」起来

方案对比：从慢到快

三大并发模型对比

为什么 I/O 密集型可以用成千上万个协程？

代码示例

Python asyncio — I/O 密集任务的正确打开方式：

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as resp:
        return await resp.text()

async def main():
    urls = [f"https://api.example.com/data/{i}" for i in range(1000)]

    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        # 1000 个网络请求，只用一个线程，几乎同时完成！

asyncio.run(main())

Go goroutine — 同样轻松处理成千上万个 I/O 任务：

// Go：goroutine 是轻量级协程，几 KB 一个，可以开数万个
package main

import (
    "fmt"
    "net/http"
    "sync"
)

func main() {
    urls := make([]string, 1000)
    for i := range urls {
        urls[i] = fmt.Sprintf("https://api.example.com/data/%d", i)
    }

    var wg sync.WaitGroup
    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            http.Get(u)  // 阻塞在 IO，Go 运行时会自动调度其他 goroutine
        }(url)
    }
    wg.Wait()
    // 1000 个并发请求，goroutine 切换开销几乎为零
}

📊 技术选型矩阵 — 一图看懂该用什么

混合型场景：Python 示例

import asyncio
from concurrent.futures import ProcessPoolExecutor
import aiohttp

# CPU 密集任务 — 放到进程池执行（绕开 GIL）
def cpu_heavy_task(data):
    return sorted(data)  # 假设是大数据排序

async def handle_request(data):
    loop = asyncio.get_running_loop()

    # I/O 部分：协程异步处理
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            raw_data = await resp.json()

    # CPU 部分：丢到进程池执行，不阻塞事件循环
    with ProcessPoolExecutor() as pool:
        result = await loop.run_in_executor(pool, cpu_heavy_task, raw_data)

    return result

🗺️ 各语言生态速查

🎯 一句话总结 + 速查表