⚡ 并发模型大全

并发 (Concurrency) vs 并行 (Parallelism)

并发：多个任务在同一时间段内交替执行，看起来像是同时进行，实际上 CPU 在多个任务之间快速切换。核心是逻辑上的同时。

并行：多个任务在同一时刻真正同时执行，需要多核 CPU 或多台机器。核心是物理上的同时。

同步 (Sync) vs 异步 (Async)

同步：调用方发起请求后，必须等待被调用方完成并返回结果，期间调用方线程被阻塞。

异步：调用方发起请求后立即返回，不等待结果。被调用方完成后通过回调、事件、Promise 等方式通知调用方。

阻塞 (Blocking) vs 非阻塞 (Non-blocking)

阻塞：调用后线程被挂起，直到操作完成才恢复。期间线程不能做任何其他事情。

非阻塞：调用后立即返回一个状态（如 EAGAIN / EWOULDBLOCK），线程可以继续执行其他任务，稍后再检查操作是否完成。

四者的关系矩阵

多进程 Multi-Process

利用操作系统的 fork() 或 spawn() 创建多个独立的进程，每个进程有独立的内存空间，通过 IPC（进程间通信）如管道、消息队列、共享内存、Socket 等进行数据交互。

# Python multiprocessing 示例
from multiprocessing import Process

def worker(name):
    print(f"Worker {name} running")

p1 = Process(target=worker, args=("A",))
p2 = Process(target=worker, args=("B",))
p1.start(); p2.start()
p1.join();  p2.join()

进程池 Process Pool

预先创建固定数量的进程，任务到来时从池中取出空闲进程执行，完成后归还。避免频繁创建/销毁进程的开销。

多线程 Multi-Threading

在同一个进程内创建多个线程，共享堆内存，各自拥有独立的栈和寄存器。操作系统负责线程调度（抢占式），时间片轮转。需要锁机制来保护共享数据。

线程池 Thread Pool

预先创建 N 个线程放入池中，通过任务队列分配工作。核心思路：用少量线程处理大量任务，避免线程创建/销毁开销。

共享内存 + 锁 Shared Memory & Locking

多线程/多进程通过共享内存区域交换数据，必须配合同步原语保证正确性。这不是一个独立的「模型」，而是几乎所有多线程/多进程方案都要面对的核心问题。

同步阻塞 I/O Blocking I/O

应用调用 read()，如果内核数据未就绪，线程被挂起直到数据从内核拷贝到用户空间。这是最简单也最低效的模型。

同步非阻塞 I/O Non-blocking I/O

将 socket 设为非阻塞模式，read() 立即返回。如果数据未就绪，返回错误码 EAGAIN，应用需要反复轮询直到数据就绪。CPU 空转严重，实际中很少单独使用。

I/O 多路复用 I/O Multiplexing

这是高性能网络服务的基石。一个线程同时监听多个 socket，当至少一个 socket 数据就绪时返回，然后逐个处理。核心思想：「一个线程管理多个连接」。

异步 I/O Asynchronous I/O (AIO)

应用发起 aio_read() 后立即返回，内核在后台完成「等待数据 + 拷贝到用户空间」的全过程，完成后通过信号或回调通知应用。全程无阻塞。

协程概述 Coroutine

协程是一种能在执行中主动让出（yield）控制权、之后再恢复（resume）的函数。与线程的抢占式调度不同，协程是协作式调度，切换点由程序员显式控制。

async / await Async / Await 模式

现代语言（Python、JS/TS、Rust、C#、Dart、Swift）普遍采用的协程语法糖。用同步风格的代码写异步逻辑，大幅降低心智负担。

# Python
async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.text()

// JavaScript
async function fetch(url) {
    const resp = await fetch(url);
    return await resp.text();
}

// Rust
async fn fetch(url: &str) -> Result<String> {
    let resp = reqwest::get(url).await?;
    resp.text().await
}

事件循环 Event Loop

事件循环是一个永远运行的循环，持续从事件队列中取出事件并分发给对应的处理器。典型流程：收集事件 → 分发事件 → 处理事件 → 循环。

Reactor 模式 Reactor Pattern

Reactor 模式 = 事件循环 + I/O 多路复用 + 事件分发。核心是同步非阻塞地监听事件，然后同步地（或分发到线程池）处理事件。

Proactor 模式 Proactor Pattern

Proactor 更进一步：I/O 操作完全由内核异步完成，完成后通知应用。应用不需要参与数据读取过程，只需处理已经准备好数据的结果。

典型实现是 Windows IOCP 和 Linux io_uring。内核帮你把数据读到缓冲区，然后通知你「数据已经在这了，直接处理」。

CSP Communicating Sequential Processes

CSP 由 Tony Hoare 于 1978 年提出。核心概念：协程（goroutine）+ 通道（channel）。数据通过 channel 在 goroutine 间传递，channel 本身是同步点，天然保证数据安全。

// Go — CSP 的典范实现
func main() {
    ch := make(chan string)

    go func() {          // goroutine（协程）
        time.Sleep(1 * time.Second)
        ch <- "hello"        // 通过 channel 发送
    }()

    msg := <-ch               // 通过 channel 接收（阻塞直到有数据）
    fmt.Println(msg)
}

// select 多路复用
select {
case msg1 := <-ch1:
    fmt.Println(msg1)
case msg2 := <-ch2:
    fmt.Println(msg2)
case <-time.After(1 * time.Second):
    fmt.Println("timeout")
}

Actor Model Actor 模型

Actor 模型由 Carl Hewitt 于 1973 年提出。每个 Actor 是一个独立计算单元，有自己的状态和 mailbox（消息队列）。Actor 之间完全通过异步消息通信，不共享任何内存。

MapReduce

Google 2004 年提出的大规模数据处理范式。分两个阶段：Map（将输入数据映射为键值对中间结果）→ Shuffle（按 key 分组）→ Reduce（对每组数据聚合）。

Fork / Join

将大任务递归地Fork（拆分）为小任务并行执行，最后Join（合并）结果。核心数据结构是工作窃取（Work-Stealing）双端队列，空闲线程从繁忙线程的队列尾部偷任务，实现负载均衡。

// Java ForkJoinPool — 递归求和
class SumTask extends RecursiveTask<Long> {
    protected Long compute() {
        if (high - low <= THRESHOLD) {
            return directSum(low, high);
        }
        mid = (low + high) / 2;
        left  = new SumTask(low, mid).fork();   // 异步拆分
        right = new SumTask(mid, high).fork();
        return left.join() + right.join();  // 等待并合并
    }
}

单线程异步 Single-Threaded Async

以 Node.js 为典型代表：一个主线程 + 事件循环 + 异步非阻塞 I/O。主线程处理所有 JavaScript 代码，I/O 操作委托给 libuv 线程池或操作系统异步接口，完成后通过回调/事件返回主线程。

// Node.js — 单线程异步
const fs = require('fs');
const http = require('http');

// 非阻塞读取，完成后回调
fs.readFile('large.txt', (err, data) => {
    // 这个回调稍后在事件循环中执行
    console.log(data.length);
});
console.log('我先输出！');  // 这行先执行

响应式编程 Reactive Programming

以数据流（Stream）和变化传播为核心。将一切视为异步数据流，通过声明式操作符（map、filter、flatMap）组合和变换流。天然支持背压（Backpressure），即消费者可以通知生产者放慢速度。

代表：ReactiveX（RxJava、RxJS、RxSwift）、Project Reactor（Spring WebFlux 底层）、Akka Streams

STM Software Transactional Memory

借鉴数据库事务思想，将对共享内存的读写包装为原子事务。事务内对共享变量的修改对其他线程不可见，提交时检测冲突，有冲突则回滚重试。代表：Clojure STM、Haskell STM、C++ 实验性实现。

流水线并发 Pipeline Concurrency

将处理流程拆分为多个阶段（Stage），每个阶段在独立的线程/进程中运行，阶段之间通过队列传递数据。类似于工厂流水线，多个物品可以在不同阶段同时处理。

决策树：我需要什么并发模型？

💡 核心原则总结

1. I/O 密集 → 用异步（协程 / 事件循环 / goroutine），不要让线程在 I/O 上白白等待
2. CPU 密集 → 用多核（多进程 / Fork-Join / GPU），让每个核心都跑满
3. 共享状态复杂 → 用消息传递（CSP / Actor），不要通过共享内存来通信
4. 高可用需求 → 用 Actor（Let It Crash + Supervisor 树），容错是第一优先级
5. 简单优先 → 单线程异步足够时不要上多线程，复杂度往往比性能损耗更昂贵
6. 没有银弹 —— 现代系统通常是多种模型的组合（如 Rust：tokio 异步运行时 + rayon 数据并行 + channel 消息传递）