当前位置： 首页 > news >正文

C++ 多线程编程

news 2025/9/4 5:06:28

1. 核心头文件

要使用 C++ 多线程，首先需要包含以下头文件：

cpp

#include <thread>   // 线程管理（创建、休眠、获取ID等）
#include <mutex>    // 互斥锁（std::mutex, std::lock_guard, std::unique_lock）
#include <atomic>   // 原子操作（无锁编程）
#include <future>   // 异步操作（std::async, std::promise, std::future）
#include <condition_variable> // 条件变量（线程间同步）

2. 创建线程

创建线程最基本的方式是使用 std::thread 类，其构造函数接受一个可调用对象（函数、Lambda表达式、函数对象等）以及该对象所需的参数。

示例1：使用函数

cpp

#include <iostream>
#include <thread>void helloFunction() {std::cout << "Hello from function! Thread ID: " << std::this_thread::get_id() << std::endl;
}int main() {// 创建线程对象 t1，并立即执行 helloFunctionstd::thread t1(helloFunction);// 使用 Lambda 表达式创建线程 t2std::thread t2([](){std::cout << "Hello from lambda! Thread ID: " << std::this_thread::get_id() << std::endl;});// 等待两个线程执行完毕t1.join(); // main 线程阻塞，直到 t1 完成t2.join(); // main 线程阻塞，直到 t2 完成std::cout << "Main thread done." << std::endl;return 0;
}

重要提示：

  • join(): 等待子线程结束，然后继续执行主线程。必须在你创建的 std::thread 对象被销毁前调用 join() 或 detach()，否则程序会调用 std::terminate 终止。

  • detach(): 将子线程与主线程分离，使其成为守护线程（daemon thread），在后台独立运行。一旦分离，你将无法再与之交互。通常用于长时间运行的任务。

3. 数据共享与竞态条件

当多个线程读写同一块共享数据时，如果没有任何同步措施，程序的执行结果将变得不确定，这就是竞态条件。

示例：一个有问题的计数器

cpp

#include <thread>
#include <iostream>int counter = 0;void incrementCounter(int numIterations) {for (int i = 0; i < numIterations; ++i) {++counter; // 这不是原子操作！}
}int main() {const int numIterations = 1000000;std::thread t1(incrementCounter, numIterations);std::thread t2(incrementCounter, numIterations);t1.join();t2.join();// 结果几乎肯定不是 2000000std::cout << "Final counter value: " << counter << std::endl;return 0;
}

++counter 看起来是一条语句，但底层对应读取-修改-写入三条指令，线程可能会在这三条指令之间被中断，导致数据覆盖。

4. 使用互斥锁保护共享数据

互斥锁（Mutex） 是最常用的同步原语。它保证同一时间只有一个线程能进入被保护的代码段（临界区）。

a. std::mutex 和 std::lock_guard

std::lock_guard 是一个 RAII 类，在构造时自动加锁，在析构时自动解锁，避免了手动解锁的麻烦，异常安全。

cpp

#include <thread>
#include <iostream>
#include <mutex>int counter = 0;
std::mutex counter_mutex; // 保护 counter 的互斥锁void safeIncrement(int numIterations) {for (int i = 0; i < numIterations; ++i) {std::lock_guard<std::mutex> lock(counter_mutex); // 构造时加锁++counter; // 临界区// lock 析构时自动解锁}
}int main() {const int numIterations = 1000000;std::thread t1(safeIncrement, numIterations);std::thread t2(safeIncrement, numIterations);t1.join();t2.join();// 结果总是 2000000std::cout << "Final counter value: " << counter << std::endl;return 0;
}
b. std::unique_lock

std::unique_lock 比 std::lock_guard 更灵活（但开销稍大），可以延迟加锁、手动解锁/加锁，并且是条件变量所必需的。

cpp

std::mutex mtx;
void complexFunction() {std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // 延迟加锁// ... do some work that doesn't need the lock ...lock.lock(); // 现在手动加锁// ... critical section ...lock.unlock(); // 可以手动解锁// ... more non-critical work ...// 如果锁还在，析构时会自动解锁
}

5. 原子操作

对于简单的计数器，使用 std::atomic 类型是更轻量级且高效的选择。它通过硬件指令保证操作的原子性，无需锁。

cpp

#include <atomic>
#include <thread>
#include <iostream>std::atomic<int> atomic_counter(0); // 原子整数void atomicIncrement(int numIterations) {for (int i = 0; i < numIterations; ++i) {++atomic_counter; // 这是一个原子操作// atomic_counter.fetch_add(1, std::memory_order_relaxed); // 也可以这样写}
}int main() {const int numIterations = 1000000;std::thread t1(atomicIncrement, numIterations);std::thread t2(atomicIncrement, numIterations);t1.join();t2.join();// 结果总是 2000000，且性能比用互斥锁高std::cout << "Final atomic counter value: " << atomic_counter << std::endl;return 0;
}

适用场景：适用于单个变量（整数、指针、甚至自定义结构，如果满足特定条件）的简单读写、递增、比较交换（CAS）等操作。

6. 条件变量

条件变量允许线程在某个条件不满足时主动阻塞（睡眠），直到另一个线程通知条件可能已改变。它必须和互斥锁一起使用。

经典模式：生产者-消费者

cpp

#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <iostream>std::queue<int> data_queue;
std::mutex mtx;
std::condition_variable cv;void data_producer() {for (int i = 0; i < 10; ++i) {std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟生产耗时{std::lock_guard<std::mutex> lock(mtx);data_queue.push(i);std::cout << "Produced: " << i << std::endl;}cv.notify_one(); // 通知一个等待的消费者}
}void data_consumer() {while (true) {std::unique_lock<std::mutex> lock(mtx);// 等待条件：队列不为空。lambda 表达式是谓词，防止虚假唤醒cv.wait(lock, []{ return !data_queue.empty(); });int data = data_queue.front();data_queue.pop();lock.unlock(); // 尽早释放锁std::cout << "Consumed: " << data << std::endl;if (data == 9) break; // 简单终止条件}
}int main() {std::thread producer(data_producer);std::thread consumer(data_consumer);producer.join();consumer.join();return 0;
}

  • cv.wait(lock, predicate)：会原子地解锁 lock 并阻塞当前线程。当被 notify 唤醒时，它会重新获取锁，并检查 predicate。如果 predicate 返回 false，它会继续等待。

  • 防止虚假唤醒：使用带谓词的 wait 是标准做法，因为条件变量可能因为系统原因被意外唤醒。

7. 异步操作与 Future/Promise

<future> 头文件提供了更高层次的抽象，用于获取异步任务（在其他线程上运行的任务）的结果。

a. std::async 和 std::future

最简单的启动异步任务的方式。

cpp

#include <future>
#include <iostream>int expensiveCalculation(int x) {std::this_thread::sleep_for(std::chrono::seconds(2));return x * x;
}int main() {// 启动一个异步任务// std::launch::async 保证在新线程中执行// std::launch::deferred 表示延迟计算（直到调用 get() 时才在当前线程执行）std::future<int> result_future = std::async(std::launch::async, expensiveCalculation, 10);std::cout << "Doing some other work..." << std::endl;// .get() 会阻塞，直到异步任务完成并返回结果int result = result_future.get();std::cout << "Result: " << result << std::endl; // Output: Result: 100return 0;
}
b. std::promise 和 std::future

std::promise 允许你在一个线程中设置一个值（或异常），并通过与之关联的 std::future 在另一个线程中获取它。这是一种更手动的线程间传递结果的机制。

cpp

void doWork(std::promise<int> prom) {std::this_thread::sleep_for(std::chrono::seconds(2));prom.set_value(42); // 设置结果
}int main() {std::promise<int> myPromise;std::future<int> myFuture = myPromise.get_future();std::thread worker(doWork, std::move(myPromise)); // promise 不可复制，只能移动std::cout << "Waiting for the result..." << std::endl;int result = myFuture.get(); // 阻塞并获取结果std::cout << "The answer is: " << result << std::endl;worker.join();return 0;
}

最佳实践与注意事项

  1. 优先使用 RAII：始终使用 std::lock_guard 或 std::unique_lock 来管理锁，而不是手动调用 lock() 和 unlock()，以确保异常安全。

  2. 缩小临界区：锁的粒度要细。只在绝对必要的时候持有锁，锁住后尽快释放。

  3. 避免死锁：以固定的顺序获取多个锁（例如，总是先锁 mutex A，再锁 mutex B），或者使用 std::lock(m1, m2, ...) 来一次性锁住多个互斥量而避免死锁。

  4. 考虑无锁编程：对于简单的数据，优先考虑 std::atomic。

  5. 线程不宜过多：线程的创建和上下文切换有开销。线程数量通常与 CPU 核心数相匹配是较好的起点。对于 I/O 密集型任务，可以多一些。

  6. 使用高级抽象：如果可能，优先使用 std::async 和 std::future，而不是手动管理 std::thread 和同步原语，这可以减少错误。

  7. 注意线程安全：标准库的容器和函数通常不是线程安全的（除了像 std::atomic 这样的特例）。多个线程读写同一个容器必须手动加锁。

C++ 多线程编程是一个庞大而复杂的主题，这里只是冰山一角。但掌握了这些核心概念（thread, mutex, atomic, condition_variable, future），你已经可以应对绝大多数多线程开发场景了。实践中，务必谨慎小心，多使用线程检查工具（如 ThreadSanitizer）来发现潜在的竞态条件和死锁。

http://www.xdnf.cn/news/1438903.html

相关文章：

  • c++多线程（1）------创建和管理线程td::thread
  • logging：报告状态、错误和信息消息
  • 《用 Flask + SQLAlchemy 构建任务管理应用：从基础架构到实战优化》
  • 面试题：JVM与G1要点总结
  • 哪些AI生成PPT的软件或网站支持多平台使用？都支持哪些平台？
  • Linux之centos 系统常用命令详解（附实战案例）
  • 多路复用 I/O 函数——`select`函数解析
  • 一次惊心动魄的线上事故：记一次内存泄漏Bug的排查与解决全过程
  • 从一道面试题开始：如何让同时启动的线程按顺序执行？
  • Bug排查日记：从发现到解决的完整记录
  • 在word中使用lateX公式的方法
  • 力扣115:不同的子序列
  • Unity Android 文件的读写
  • Delphi 5 中操作 Word 表格时禁用鼠标交互
  • 更新远程分支 git fetch
  • 揭开PCB隐形杀手：超周期报废的技术真相
  • AI编码生产力翻倍：你必须掌握的沟通、流程、工具与安全心法
  • 一键掌握服务器健康状态与安全风险
  • 同步工具的底层依赖：AQS
  • Kubernetes 中为 ZenTao 的 Apache 服务器添加请求体大小限制
  • 如何开发一款高稳定、低延迟、功能全面的RTSP播放器？
  • 时序数据库选型指南：为何Apache IoTDB成为工业物联网首选
  • JVM分析（OOM、死锁、死循环）（JProfiler、arthas、jvm自带工具）
  • STM32 - Embedded IDE - GCC - 使用 GCC 链接脚本限制 Flash 区域
  • 【Android】从复用到重绘的控件定制化方式
  • HarmonyOS 应用开发深度解析：基于 ArkTS 的声明式 UI 与状态管理艺术
  • HarmonyOS安装以及遇到的问题
  • Jenkins-Ansible部署discuz论坛
  • 38.Ansible判断+实例
  • PINN物理信息神经网络用于求解二阶常微分方程（ODE）的边值问题，Matlab实现