线程访问模型 on Dorkytiger 的小屋

SPSC (单写单读) 的极致优化

Mon, 01 Jan 0001 00:00:00 +0000

SPSC（Single Producer Single Consumer）是并发队列的性能天花板。因为只有一个线程写、一个线程读，我们完全不需要CAS，只需要内存屏障保证可见性，就能实现每秒数亿次的数据交换。

1. SPSC 为什么可以零 CAS？

多生产者/多消费者 (MPMC): 需要CAS保证原子性
    ↓
单生产者/多消费者 (SPMC): 需要CAS保护生产者竞争
    ↓
多生产者/单消费者 (MPSC): 需要CAS保护消费者竞争
    ↓
单生产者/单消费者 (SPSC): 
    - 写指针 (head)：只有生产者修改 → 不需要原子操作
    - 读指针 (tail)：只有消费者修改 → 不需要原子操作
    - 唯一需求：生产者写完数据后，消费者能看到 → 需要内存屏障

核心认知：SPSC不需要任何原子RMW（Read-Modify-Write）指令，只需要：

普通内存拷贝（memcpy）
Release屏障（生产者写完数据后刷新Store Buffer）
Acquire屏障（消费者读取数据前清空Invalidation Queue）

2. 环形缓冲区（Ring Buffer）—— SPSC的经典实现

数据结构

template<typename T, size_t Capacity>
class SPSCRingBuffer {
    static_assert((Capacity & (Capacity - 1)) == 0, 
                  "Capacity must be power of 2 for efficient modulo");
    
    // 缓存行对齐：避免伪共享
    alignas(64) std::atomic<size_t> head{0};  // 生产者写位置 (消费者读)
    alignas(64) std::atomic<size_t> tail{0};  // 消费者读位置 (生产者写)
    
    // 数据存储：缓存行对齐，避免伪共享
    alignas(64) T buffer[Capacity];
    
public:
    // 生产者：写入数据
    bool enqueue(const T& item) {
        const size_t current_head = head.load(std::memory_order_relaxed);
        const size_t next_head = (current_head + 1) & (Capacity - 1);
        
        // 检查队列是否已满
        if (next_head == tail.load(std::memory_order_acquire)) {
            return false; // 队列满
        }
        
        // 写入数据 (普通内存拷贝)
        buffer[current_head] = item;
        
        // Release屏障：确保数据写入完成，再更新head
        // 等价于: std::atomic_thread_fence(std::memory_order_release)
        head.store(next_head, std::memory_order_release);
        return true;
    }
    
    // 消费者：读取数据
    bool dequeue(T& item) {
        const size_t current_tail = tail.load(std::memory_order_relaxed);
        
        // 检查队列是否为空
        if (current_tail == head.load(std::memory_order_acquire)) {
            return false; // 队列空
        }
        
        // 读取数据 (普通内存拷贝)
        item = buffer[current_tail];
        
        // Acquire屏障：确保数据读取前，tail更新已完成
        const size_t next_tail = (current_tail + 1) & (Capacity - 1);
        tail.store(next_tail, std::memory_order_release);
        return true;
    }
};

内存布局图示

环形缓冲区 (Capacity=8, 掩码=7):
+------------------------------------------------------------------+
| 索引: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |  (使用位运算 & 7 取模)    |
+------------------------------------------------------------------+
      ↑                    ↑
      |                    |
    tail (消费者)       head (生产者)
    
生产者在 head 处写入，然后 head = (head+1) & 7
消费者在 tail 处读取，然后 tail = (tail+1) & 7

当 head == tail → 队列空
当 (head+1) & 7 == tail → 队列满 (留一个空位区分空和满)

3. 性能核武器：批量处理（Batch Processing）

单元素入队/出队虽然快，但批量操作能把吞吐量推向极致。

MPSC (多写单读) 在异步系统中的落地

Mon, 01 Jan 0001 00:00:00 +0000

这个问题直接触及异步系统设计的灵魂！MPSC（Multi-Producer Single-Consumer）是日志系统、网络收包、数据库WAL的黄金模型。我们的目标很明确：让成千上万个生产者疯狂提交任务，而单个消费者线程以内存带宽极限速度刷盘/处理。

1. MPSC 的天然困境：多写竞争

MPSC 的难点在于：

多个生产者争抢同一个队列 → 需要 CAS 保护。
一个消费者需要看到所有生产者的提交 → 需要全局可见性。

如果直接用 push + CAS 逐个入队，在高并发下会产生缓存行乒乓（所有生产者都在抢 head 指针的缓存行），吞吐量断崖式下跌。

解决方案：批量提交（Batch Submission） + 本地缓冲（Thread-Local Buffer）。

2. MPSC 批量提交流程（三阶段）

核心思想：每个生产者先攒一批，然后一次 CAS 把整批交给消费者。

[阶段1: 生产者本地缓冲]
    每个线程有自己的本地队列 (线程局部存储)
    任务先写入本地队列 (无竞争，极快)

[阶段2: CAS 批量提交]
    本地队列满了 (或超时) → 获取共享队列的全局锁（一次CAS）
    把整批任务挂到共享队列尾部

[阶段3: 消费者批量消费]
    消费者一次性取走所有任务 (使用内存屏障保证可见性)
    批量处理/刷盘 → 极高吞吐

3. 工业级 MPSC 队列实现（批处理 + 环形缓冲区）

数据结构设计

template<typename T, size_t LocalBatchSize = 256, size_t GlobalSize = 1024 * 1024>
class MPSCBatchQueue {
    // ============ 全局共享队列 (环形缓冲区) ============
    struct GlobalQueue {
        alignas(64) std::atomic<size_t> write_index{0};  // 生产者CAS抢位置
        alignas(64) std::atomic<size_t> read_index{0};   // 消费者读位置
        alignas(64) T buffer[GlobalSize];
        
        // 保证容量是2的幂，使用位运算取模
        static constexpr size_t MASK = GlobalSize - 1;
        static_assert((GlobalSize & (GlobalSize - 1)) == 0, 
                      "GlobalSize must be power of 2");
    };
    GlobalQueue global_queue;
    
    // ============ 生产者本地缓冲 (线程局部) ============
    struct LocalBuffer {
        size_t count{0};
        T items[LocalBatchSize];
    };
    
    // 线程局部存储：每个生产者有自己的缓冲
    thread_local static LocalBuffer local_buffer;

public:
    // 生产者接口：提交单个任务
    bool enqueue(const T& item) {
        // 1. 写入本地缓冲 (无竞争，极快)
        local_buffer.items[local_buffer.count++] = item;
        
        // 2. 如果本地缓冲满了，批量提交到全局队列
        if (local_buffer.count >= LocalBatchSize) {
            flush_local_buffer();
        }
        return true;
    }
    
    // 生产者接口：强制刷新（如程序退出前）
    void flush() {
        flush_local_buffer();
    }
    
    // 消费者接口：批量获取任务
    struct Batch {
        const T* data;
        size_t count;
    };
    
    Batch dequeue_batch() {
        const size_t current_read = global_queue.read_index.load(std::memory_order_acquire);
        const size_t current_write = global_queue.write_index.load(std::memory_order_acquire);
        
        size_t available = current_write - current_read;
        if (available == 0) {
            return {nullptr, 0}; // 队列空
        }
        
        // 尽量一次性取出所有可用数据 (但不要超过环形缓冲区边界)
        size_t count = std::min(available, GlobalSize - (current_read & GlobalQueue::MASK));
        const T* data = &global_queue.buffer[current_read & GlobalQueue::MASK];
        
        // 注意：这里不立即更新read_index，让消费者处理完再更新
        // (或者使用双指针技术，下面会讲)
        return {data, count};
    }
    
    // 消费者接口：提交消费进度 (批量标记已处理)
    void commit_read(size_t count) {
        size_t new_read = global_queue.read_index.load(std::memory_order_relaxed) + count;
        global_queue.read_index.store(new_read, std::memory_order_release);
    }

private:
    // 批量提交本地缓冲到全局队列
    void flush_local_buffer() {
        if (local_buffer.count == 0) return;
        
        // 1. 用 CAS 抢占全局队列的写入位置 (唯一原子操作!)
        size_t start_index = global_queue.write_index.fetch_add(
            local_buffer.count, std::memory_order_acquire);
        
        // 2. 计算在环形缓冲区中的起始位置
        size_t start_pos = start_index & GlobalQueue::MASK;
        size_t end_pos = (start_index + local_buffer.count) & GlobalQueue::MASK;
        
        // 3. 复制数据到全局队列 (可能跨越环形边界)
        if (start_pos < end_pos) {
            // 不跨越边界：直接拷贝
            memcpy(&global_queue.buffer[start_pos], 
                   local_buffer.items, 
                   local_buffer.count * sizeof(T));
        } else {
            // 跨越边界：分两段拷贝
            size_t first_part = GlobalSize - start_pos;
            memcpy(&global_queue.buffer[start_pos], 
                   local_buffer.items, 
                   first_part * sizeof(T));
            memcpy(&global_queue.buffer[0], 
                   &local_buffer.items[first_part], 
                   (local_buffer.count - first_part) * sizeof(T));
        }
        
        // 4. 清空本地缓冲
        local_buffer.count = 0;
    }
};

4. 性能关键：消费者"双指针"技术

消费者如果每处理完一条就更新 read_index，会产生大量缓存行写操作。优化的做法是：消费者批量处理，只更新一次 read_index。

SPMC (单写多读) 与线程池任务分发（Work-Stealing）

Mon, 01 Jan 0001 00:00:00 +0000

1. SPMC（单写多读）的硬件本质

场景定义

1个写者（Writer）：生产数据（如配置更新、日志聚合、时钟信号）。
N个读者（Reader）：各自独立消费数据（如多个统计线程、监控面板、热备进程）。

硬件挑战：写者如何让所有读者看到最新数据？

方案A：共享锁（`std::shared_mutex`）—— 读者间乒乓

std::shared_mutex mtx;
int shared_data;

void writer() {
    std::unique_lock lock(mtx);
    shared_data = new_value; // 独占锁 → 缓存行 E→M
}

void reader() {
    std::shared_lock lock(mtx);
    int local = shared_data; // 共享锁 → 缓存行 E→S
}

硬件代价：

写者修改时，发 RFO（Read For Ownership），使所有读者的缓存行失效（I状态）。
读者读时，重新从主存/写者缓存加载（Cache Miss + 总线流量）。
缓存行在N+1个核心间频繁迁移，延迟随读者数线性增加。

方案B：RCU（Read-Copy-Update）—— 读者零开销

std::atomic<int*> global_ptr; // 指向共享数据的指针

void writer() {
    int* old = global_ptr.load(std::memory_order_acquire);
    int* new_data = new int(*old); // 拷贝
    *new_data = new_value;
    global_ptr.store(new_data, std::memory_order_release); // 发布新指针
    // 等待所有读者退出后，delete old (延迟回收)
}

void reader() {
    int* data = global_ptr.load(std::memory_order_acquire);
    int local = *data; // 完全无锁，无原子操作（除了指针load）
}

硬件行为：

MPMC (多写多读) 与工业级无锁队列（如 LMAX Disruptor）

Mon, 01 Jan 0001 00:00:00 +0000

欢迎来到并发编程的“诸神之战”——MPMC（Multi-Producer Multi-Consumer）。

这是并发领域最难啃的骨头，也是区分“普通程序员”和“系统架构师”的分水岭。你之前的 SPSC 是“单行道”，MPSC 是“多入口单出口”，而 MPMC 是**“多入口多出口的疯狂立交桥”**。

要把 MPMC 写好，靠 CAS 硬刚是不行的，那会让 CPU 缓存行“炸裂”。我们需要引入工业级杀器：LMAX Disruptor（无锁环形缓冲区）。

1. MPMC 的“两头肉搏”到底有多痛？

在 MPMC 中，所有生产者和消费者都盯着同一个头指针（Head）和同一个尾指针（Tail）。

生产者肉搏：N 个生产者疯狂 CAS 抢 Head（分配槽位）。每次 CAS 都是 RFO（Read For Ownership），导致 Head 所在的缓存行在 N 个核心间“乒乓”。
消费者肉搏：M 个消费者疯狂 CAS 抢 Tail（消费进度）。同样导致缓存行在 M 个核心间“乒乓”。
头尾互搏：更恐怖的是，Head 和 Tail 如果在同一个缓存行（False Sharing），生产者抢 Head 还会顺便把 Tail 的缓存行弄脏，直接拖垮消费者。

结果：吞吐量随着核心数增加不升反降，延迟飙升到微秒级。

2. 顶级框架 LMAX Disruptor 的“核心理念”

LMAX 是金融交易系统（每秒处理 600 万笔订单），它解决 MPMC 的思路极其高明，核心就两招：

干掉竞争（CAS）：用顺序分配 + 栅栏（Barrier）代替互斥。生产者不抢同一个指针，而是各自申请一段连续的空间。
干掉伪共享：缓存行填充（Cache Line Padding），让 Head、Tail、Cursor 老死不相往来。

3. 核心机制：申请（Claim）与发布（Publish）

Disruptor 不直接操作指针，而是通过序号（Sequence）：

线程访问模型 on Dorkytiger 的小屋

SPSC (单写单读) 的极致优化

1. SPSC 为什么可以零 CAS？

2. 环形缓冲区（Ring Buffer）—— SPSC的经典实现

数据结构

内存布局图示

3. 性能核武器：批量处理（Batch Processing）

MPSC (多写单读) 在异步系统中的落地

1. MPSC 的天然困境：多写竞争

2. MPSC 批量提交流程（三阶段）

核心思想：每个生产者先攒一批，然后一次 CAS 把整批交给消费者。

3. 工业级 MPSC 队列实现（批处理 + 环形缓冲区）

数据结构设计

4. 性能关键：消费者"双指针"技术

SPMC (单写多读) 与 线程池任务分发（Work-Stealing）

1. SPMC（单写多读）的硬件本质

场景定义

硬件挑战：写者如何让所有读者看到最新数据？

方案A：共享锁（std::shared_mutex）—— 读者间乒乓

方案B：RCU（Read-Copy-Update）—— 读者零开销

MPMC (多写多读) 与 工业级无锁队列（如 LMAX Disruptor）

1. MPMC 的“两头肉搏”到底有多痛？

2. 顶级框架 LMAX Disruptor 的“核心理念”

3. 核心机制：申请（Claim）与 发布（Publish）

SPMC (单写多读) 与线程池任务分发（Work-Stealing）

方案A：共享锁（`std::shared_mutex`）—— 读者间乒乓

MPMC (多写多读) 与工业级无锁队列（如 LMAX Disruptor）

3. 核心机制：申请（Claim）与发布（Publish）