QC++ / Qt 学习之路

并发编程

用标准库线程、互斥量与 future 写出正确的并发代码

进阶第 12 / 48 章第二篇 · C++ 进阶与工程实践

#先建立正确的心智模型

如果你从 Java 转过来,C++ 的并发模型会让你意外地熟悉:std::thread 对应 Thread,std::mutex 对应 synchronized 的底层原语,condition_variable 就是 wait/notify 那套机制。从 Python 过来则要重新适应——CPython 有 GIL,多线程几乎无法并行执行字节码,所以 Python 程序员习惯用多进程或 asyncio 绕开;而 C++ 的线程是真正的操作系统线程,没有全局锁,能跑满多核,代价是每一个数据竞争都要你自己负责。至于 JavaScript 的单线程事件循环,它用「不存在共享内存」的方式回避了整个问题域:Web Worker 之间靠消息传递,天然没有数据竞争。C++ 走的是最硬核的路线——共享内存 + 显式同步。

数据竞争 Data Race 与互斥锁同一块内存被多线程同时写入且无同步,结果未定义无锁:两线程同时 ++,结果错误共享变量 int cnt = 0时间线程 Aread cntcnt + 1write cnt线程 Bread cntcnt + 1write cnt两次 ++ 交错执行 → 丢失一次更新期望 cnt = 2实际可能为 cnt = 1lock_guard:串行执行,结果正确std::mutex m; 保护临界区时间线程 A线程 B(阻塞等待)read cntread cntcnt + 1cnt + 1write cntwrite cntlock_guard 持有锁获得锁后同样执行三次最终 cnt = 2(正确)
没有互斥保护时,两个线程的写操作会交错出错

本章默认 C++17。核心原则只有一条:只要两个线程访问同一块内存,且至少一个是写操作,且没有同步关系,就是数据竞争(data race),而数据竞争在 C++ 标准里属于未定义行为。 不是「可能出错」,是标准明确说结果不可预测。这点比 Java 严格,Java 的内存模型至少保证不出离谱结果。

#std::thread 与线程生命周期

线程对象在构造完成后立刻开始执行。关键在于:std::thread 析构时如果仍然 joinable(即线程还在运行且未被 join/detach),程序会直接调用 std::terminate 崩溃。这是新手最常踩的坑——Python 的 threading.Thread 默认是非守护线程,解释器会等它结束;Java 的线程同理。C++ 要求你显式表态。

C++
#include <chrono>
#include <iostream>
#include <thread>
#include <vector>

void worker(int id) {
    for (int i = 0; i < 3; ++i) {
        std::cout << "thread " << id << " step " << i << "\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main() {
    std::vector<std::thread> pool;
    for (int i = 0; i < 4; ++i) {
        pool.emplace_back(worker, i);      // 传参:值拷贝进线程
    }

    // 传引用必须显式 std::ref,否则是拷贝
    int shared = 0;
    std::thread t([&shared] { shared = 42; });

    for (auto& th : pool) {
        if (th.joinable()) th.join();      // join:等待结束并回收
    }
    t.join();
    std::cout << "shared = " << shared << "\n";
    std::cout << "hardware_concurrency = "
              << std::thread::hardware_concurrency() << "\n";
}

join() 是「等待并回收」,会阻塞当前线程;detach() 是「放任不管」,线程变成后台线程,资源在结束时自动回收,但一旦 detach,你必须保证它访问的所有对象活得比它久——否则就是悬垂引用。绝大多数情况下不该用 detach,正确做法是用 RAII 包装(C++20 的 std::jthread 会在析构时自动 join,还能通过 stop_token 请求取消,推荐在新项目中使用)。

异常安全也要注意:如果 join 之前的代码抛异常,线程对象析构就会终止程序,所以用 RAII 的 thread_guard 或 jthread 更稳妥。另外 std::thread 的构造函数是按值拷贝参数的,传引用必须显式写 std::ref(obj),否则你修改的只是一份副本——这一点极易出错,因为普通函数调用传引用是直接写 obj。

最后是输出问题:std::cout 本身是线程安全的(不会交错出半个字符串),但多条 << 之间会互相穿插。上面的示例之所以看起来整齐,是因为每个线程只输出一句;真实项目里需要日志库或额外的互斥量来保证行的完整性。

#数据竞争与互斥量家族

C++
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

class Counter {
public:
    void add(int n) {
        std::lock_guard<std::mutex> lk(m_);   // 构造加锁,析构解锁
        value_ += n;
    }
    int get() const {
        std::lock_guard<std::mutex> lk(m_);   // mutable mutex
        return value_;
    }
private:
    mutable std::mutex m_;
    int value_ = 0;
};

int main() {
    Counter c;
    std::vector<std::thread> ts;
    for (int i = 0; i < 8; ++i) {
        ts.emplace_back([&c] {
            for (int k = 0; k < 10000; ++k) c.add(1);
        });
    }
    for (auto& t : ts) t.join();
    std::cout << "value = " << c.get() << "\n";  // 稳定输出 80000
}

四种锁的取舍:

  • std::lock_guard:最简单,作用域内持锁,不可手动解锁。首选。
  • std::unique_lock:可延迟加锁、可 unlock()、可转移所有权,必须配合 condition_variable::wait 使用。
  • std::scoped_lock(C++17):一次锁住多个互斥量,内部用死锁避免算法(类似 std::lock),彻底解决加锁顺序导致的死锁。取代手写 lock_guard 套两层。
  • std::shared_mutex(C++17):读写锁,多读单写,配合 shared_lock 使用。
C++
#include <map>
#include <mutex>
#include <shared_mutex>
#include <string>

class Config {
public:
    std::string get(const std::string& key) const {
        std::shared_lock<std::shared_mutex> rk(m_);   // 多个读者并行
        auto it = data_.find(key);
        return it == data_.end() ? "" : it->second;
    }
    void set(std::string key, std::string value) {
        std::unique_lock<std::shared_mutex> wk(m_);   // 写者独占
        data_[std::move(key)] = std::move(value);
    }
private:
    mutable std::shared_mutex m_;
    std::map<std::string, std::string> data_;
};

// 需要同时锁两个互斥量时:scoped_lock 用死锁避免算法,不必关心加锁顺序
struct Account {
    mutable std::mutex m_;
    int balance_ = 100;
};

bool transfer(Account& from, Account& to, int amount) {
    std::scoped_lock lk(from.m_, to.m_);   // 同时锁住两个,不会死锁
    if (from.balance_ < amount) return false;
    from.balance_ -= amount;
    to.balance_ += amount;
    return true;
}

对比 Java:synchronized 是可重入锁,编译器自动插入 monitorenter/monitorexit,退出作用域自动释放——语义上最接近 lock_guard,而且 Java 的 synchronized 还能直接配合 Object.wait/notify。C++ 的 std::mutex 不可重入,同一线程重复加锁是未定义行为(需要递归请用 std::recursive_mutex,但那通常说明设计有问题);等待机制也拆成了独立的 condition_variable,不与锁绑定。

还有一个容易被忽略的点:锁的粒度。把整个循环体锁住,多线程就退化成串行;只在真正修改共享状态的那一行加锁,才有并行收益。上面的 Counter::add 演示的是正确但低效的写法——实际项目中应该用 std::atomic 或让每个线程先在本地累加、最后合并一次。

#条件变量与生产者-消费者

互斥量解决互斥,条件变量解决「等待某个条件成立」。经典的三段式是:拿 unique_lock → wait 配合谓词 → 修改后 notify。用 lambda 谓词是必须的,它能正确处理虚假唤醒(spurious wakeup)。

C++
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>

template <typename T>
class BlockingQueue {
public:
    void push(T item) {
        {
            std::lock_guard<std::mutex> lk(m_);
            q_.push(std::move(item));
        }
        cv_.notify_one();                     // 先解锁再通知,减少唤醒抖动
    }

    T pop() {
        std::unique_lock<std::mutex> lk(m_);
        cv_.wait(lk, [this] { return !q_.empty() || closed_; });
        if (q_.empty()) throw std::runtime_error("closed");
        T item = std::move(q_.front());
        q_.pop();
        return item;
    }

    void close() {
        {
            std::lock_guard<std::mutex> lk(m_);
            closed_ = true;
        }
        cv_.notify_all();                     // 唤醒所有等待者收尾
    }

private:
    mutable std::mutex m_;
    std::condition_variable cv_;
    std::queue<T> q_;
    bool closed_ = false;
};

int main() {
    BlockingQueue<int> q;
    std::thread producer([&] {
        for (int i = 0; i < 5; ++i) q.push(i);
        q.close();
    });
    std::thread consumer([&] {
        try {
            while (true) std::cout << "got " << q.pop() << "\n";
        } catch (const std::exception&) { /* 关闭后退出 */ }
    });
    producer.join();
    consumer.join();
}

#std::atomic 与内存序入门

C++
#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

int main() {
    std::atomic<int> hits{0};
    std::atomic<bool> done{false};

    std::vector<std::thread> ts;
    for (int i = 0; i < 4; ++i) {
        ts.emplace_back([&] {
            for (int k = 0; k < 100000; ++k) {
                hits.fetch_add(1, std::memory_order_relaxed);
            }
            done.store(true, std::memory_order_release);
        });
    }
    for (auto& t : ts) t.join();
    std::cout << hits.load() << "\n";   // 400000,无锁且正确
}

原子操作是无锁的(对整型通常编译成单条 lock xadd 指令),比互斥量快一个数量级,但只适合单个变量的简单操作。内存序(memory order)入门记三条就够:

  • memory_order_relaxed:只保证原子性,不保证顺序。适合计数器这类「只关心最终值」的场景。
  • memory_order_acquire / release:成对使用,构成同步关系。release 之前的写,对 acquire 之后的读可见。上面的 done 就是典型用法。
  • memory_order_seq_cst:默认值,最强也是最慢,保证全局单一顺序。不确定时就用它。

Java 的 volatile 和 C++ 的 volatile 完全不同——前者有 acquire/release 语义,后者只防止编译器优化、对线程同步毫无帮助。这是从 Java 转 C++ 的经典误区。

#async / future / promise

std::async 是最简单的高层并发入口,适合「丢一个任务出去,稍后取结果」。

C++
#include <future>
#include <iostream>
#include <numeric>
#include <vector>

long long sum_range(const std::vector<int>& v, size_t lo, size_t hi) {
    return std::accumulate(v.begin() + lo, v.begin() + hi, 0LL);
}

int main() {
    std::vector<int> data(1'000'000, 1);

    // 显式指定 async 策略:默认可能是 deferred(延迟到 get 时才执行)
    auto f1 = std::async(std::launch::async, sum_range, std::cref(data), 0, 500'000);
    auto f2 = std::async(std::launch::async, sum_range, std::cref(data), 500'000, data.size());

    std::cout << "total = " << f1.get() + f2.get() << "\n";

    // promise:手动设置结果,常用于把回调转成 future
    std::promise<int> p;
    std::future<int> f = p.get_future();
    std::thread setter([&p] {
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        p.set_value(99);          // 或 set_exception 传递异常
    });
    std::cout << "promised = " << f.get() << "\n";
    setter.join();
}

注意三点:future::get() 只能调用一次,且会阻塞;std::async 默认策略是实现定义的,可能是 deferred(在 get() 时同步执行),想要真并发必须显式传 std::launch::async;std::future 的析构在 async 返回时会阻塞等待任务完成——这是个容易被忽略的隐式同步点。

#线程池的基本思路

线程创建销毁开销大(约数十微秒),高频小任务应该复用线程。一个最小线程池由三部分组成:一个 BlockingQueue<std::function<void()>>、一组常驻工作线程、以及提交接口。任务类型用 std::function 做类型擦除是这里唯一合理的选择——队列必须存储异构的可调用对象。想拿到返回值,就让提交接口返回 std::future<R>,内部用 packaged_task 包装。C++20 之后可以再加 std::jthread + stop_token 实现优雅关闭。

#小结

  • std::thread 析构时若仍 joinable 会 terminate;优先 join(),C++20 用 std::jthread 自动回收。
  • 数据竞争 = 未定义行为。共享可写数据必须同步:lock_guard 为默认选择,多锁用 scoped_lock,条件变量必须配 unique_lock。
  • 条件变量的 wait 必须带谓词 lambda,以应对虚假唤醒;修改状态后 notify,先解锁再通知。
  • 单变量的简单计数用 std::atomic;内存序默认用 seq_cst,只在明确知道语义时才降级。
  • std::async 必须显式 std::launch::async 才是真并发;future::get() 一次性且会阻塞。

#练习

  1. 把 Counter 的互斥量去掉,跑 8 线程各加 10000 次,观察结果是否等于 80000;再用 -fsanitize=thread 运行,阅读 ThreadSanitizer 给出的竞争报告。
  2. 为 BlockingQueue 增加 try_pop()(队列空时立即返回 std::optional<T>)和 size(),并说明为什么 size() 加锁后返回的值可能立刻失效。
  3. 用 std::async 实现并行版「统计一个大 vector 中大于阈值的元素个数」,拆成 4 段并行求和;对比单线程版本耗时。
  4. (进阶)实现一个最小线程池:submit(F&&) -> std::future<R>,内部用 packaged_task + 上一章的 BlockingQueue,支持析构时等待所有任务完成。线程数取 hardware_concurrency()。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。