concurrency-patterns

Concurrency Patterns Skill — 并发原语跨语言

何时使用

• 设计高并发服务（并行处理 / 流水线 / 扇出扇入）
• 排查 race condition / deadlock / 偶发崩溃
• 选择 mutex vs channel vs actor
• 实现 worker pool / 任务并行
• 跨语言移植并发代码

一、并发模型分类

模型	代表	哲学
共享内存 + 锁	Java / C++ / Python threading	"用锁保护共享数据"
CSP（消息传递）	Go / Erlang	"Don't communicate by sharing memory; share memory by communicating"
Actor	Erlang / Akka / Elixir	"每个 actor 自封闭，邮箱接收消息"
Async/Await	JS / Python asyncio / Rust / C#	"单线程事件循环，IO 等待时让出"
Software Transactional Memory	Clojure / Haskell	"数据库事务般的内存原子块"
Data Parallel	OpenMP / CUDA	"同一操作并行作用于数据数组"

不同语言混合使用。Go 主推 CSP 但也有 mutex；Rust 主推无锁但提供完整 sync 库。

二、关键概念区分

并发 vs 并行

并发（concurrency）：多个任务交替推进（可单核）
并行（parallelism）：多个任务同时执行（多核）

asyncio 是并发单线程；Go runtime / Java 线程池是并行多核。

进程 / 线程 / 协程

	切换成本	内存	隔离
进程	高（上下文 + TLB）	MB 级	完全
线程	中（寄存器）	KB-MB	共享地址空间
协程 / fiber	低（用户态）	KB 级	共享地址空间
Goroutine	极低	2KB 起	共享
async task	极低（栈复用）	极小	共享

Goroutine = 用户态调度的轻量线程；async/await = 编译器变换的状态机。

三、Mutex（最基础）

// Go
var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

// Rust
use std::sync::Mutex;
let counter = Mutex::new(0);
let mut guard = counter.lock().unwrap();
*guard += 1;
// guard 离开作用域自动释放（RAII）

# Python
lock = threading.Lock()
with lock:
    counter += 1

// JS 单线程，无 mutex；Web Worker 间用 SharedArrayBuffer + Atomics
const sab = new SharedArrayBuffer(4)
const view = new Int32Array(sab)
Atomics.add(view, 0, 1)

RWLock（读多写少）

var mu sync.RWMutex
mu.RLock(); ... mu.RUnlock()      // 多读
mu.Lock();  ... mu.Unlock()        // 独占写

读远多于写时显著快于普通 Mutex。

Atomic

import "sync/atomic"
var counter atomic.Int64
counter.Add(1)
counter.Load()

无锁，单变量级 / CPU 指令直接支持。比 mutex 快 5-10 倍。

四、Go 的 Channel（CSP）

// 无缓冲 — 发送阻塞直到接收
ch := make(chan int)
go func() { ch <- 42 }()
val := <-ch

// 带缓冲
ch := make(chan int, 10)

// 关闭
close(ch)
for val := range ch { ... }   // 收到所有 + close

// select 多路
select {
case v := <-ch1: ...
case ch2 <- val: ...
case <-time.After(5*time.Second): // 超时
case <-ctx.Done():               // 取消
}