多线程交替打印与协调

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

一、交替打印 FooBar（LeetCode 1115）

问题：两个线程交替打印 “foo” 和 “bar”，共 N 次。保证 foo 总是在 bar 之前。

解法 1：条件变量（std::condition_variable）

思路：

线程 A (打印 foo)    线程 B (打印 bar)
    │                     │
    │ wait(turn==foo)     │ wait(turn==bar)
    │ print foo           │ print bar
    │ turn=bar            │ turn=foo
    │ notify B            │ notify A
    │ ...                 │ ...

整体操作流程（条件变量版）：

初始化：创建互斥锁 mtx、条件变量 cv、布尔标志 foo_turn = true（表示当前该打印 foo）。
foo 线程：循环 N 次：获取锁 → cv.wait 等待 foo_turn == true（如果为 false 则阻塞释放锁）→ 打印 foo → 设置 foo_turn = false → cv.notify_one 唤醒 bar 线程 → 释放锁。
bar 线程：循环 N 次：获取锁 → cv.wait 等待 foo_turn == false（如果为 true 则阻塞）→ 打印 bar → 设置 foo_turn = true → cv.notify_one 唤醒 foo 线程 → 释放锁。
核心机制：cv.wait 在阻塞前会自动释放锁，被唤醒后重新获取锁并检查条件，保证"foo 总是在 bar 之前"的交替顺序。

class FooBar {
private:
    int n;
    mutex mtx;
    condition_variable cv;
    bool foo_turn = true;  // true: 该打印 foo, false: 该打印 bar

public:
    FooBar(int n) : n(n) {}

    void foo(function<void()> printFoo) {
        for (int i = 0; i < n; i++) {
            unique_lock<mutex> lock(mtx);          // ① 获取互斥锁
            cv.wait(lock, [this] { return foo_turn; });// ② 等待轮到 foo
                                                   //    如果 foo_turn==false，
                                                   //    释放锁并阻塞，被唤醒后重查条件
            printFoo();                            // ③ 打印 foo
            foo_turn = false;                      // ④ 标记轮到 bar
            cv.notify_one();                       // ⑤ 唤醒 bar 线程
        }                                          // ⑥ 解锁（unique_lock 析构）
    }

    void bar(function<void()> printBar) {
        for (int i = 0; i < n; i++) {
            unique_lock<mutex> lock(mtx);          // ① 获取互斥锁
            cv.wait(lock, [this] { return !foo_turn; });// ② 等待轮到 bar
            printBar();                            // ③ 打印 bar
            foo_turn = true;                       // ④ 标记轮到 foo
            cv.notify_one();                       // ⑤ 唤醒 foo 线程
        }
    }
};

关键理解：

经典并发数据结构手写

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

一、手写 MPSC（多写一读）阻塞队列

这是异步日志库的核心结构——多个生产者（业务线程）写日志，一个消费者（刷盘线程）读日志。

难点：多写需要保护，单读不需要。

整体操作流程：

push（多生产者）：
1. 获取互斥锁，保护队列的并发访问。
2. 如果队列已停止，丢弃数据。
3. 将数据推入队列。
4. 释放锁后调用 notify_one 唤醒消费者（解锁后再通知，减少线程唤醒时的锁争用）。
pop（单消费者）：
1. 获取互斥锁。
2. 等待条件：队列不为空或队列已停止（cv.wait 自动释放/重获锁）。
3. 如果已停止且队列为空，返回默认值（或抛异常）。
4. 取出队首元素并返回。
stop：
1. 获取锁，设置停止标志。
2. notify_all 唤醒消费者线程，使其从 wait 中退出。

template <typename T>
class MPSCBlockingQueue {
    std::queue<T> queue_;
    std::mutex mtx_;
    std::condition_variable cv_;
    bool stopped_ = false;

public:
    void push(T item) {
        {
            std::lock_guard<std::mutex> lock(mtx_);// ① 获取锁（多生产者互斥）
            if (stopped_) return;                  // ② 已停止则丢弃
            queue_.push(std::move(item));           // ③ 入队
        }                                          // ④ 解锁
        cv_.notify_one();                          // ⑤ 唤醒消费者（解锁后 notify 减少竞争）
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mtx_);   // ① 获取锁
        cv_.wait(lock, [this] {                    // ② 等待条件：有数据或已停止
            return stopped_ || !queue_.empty();
        });

        if (stopped_ && queue_.empty()) {
            return T{};                            // ③ 已停止且无数据 → 返回空值
        }

        T item = std::move(queue_.front());         // ④ 取出队首元素
        queue_.pop();
        return item;                                // ⑤ 返回数据
    }

    void stop() {
        {
            std::lock_guard<std::mutex> lock(mtx_);// ① 获取锁
            stopped_ = true;                        // ② 设置停止标志
        }
        cv_.notify_all();                           // ③ 唤醒所有等待的线程
    }
};

为什么叫 MPSC？

高级并发算法与同步原语手写 on Dorkytiger 的小屋

多线程交替打印与协调

一、交替打印 FooBar（LeetCode 1115）

解法 1：条件变量（std::condition_variable）

经典并发数据结构手写

一、手写 MPSC（多写一读）阻塞队列