目录
在现代应用中,多线程成为了提升程序性能的重要工具。特别是当我们希望充分利用多核 CPU 的计算能力时,C++ 提供了强大的多线程支持,可以并发地执行多个任务。今天,我们将通过易懂的讲解与实际的代码示例,帮助你掌握 C++ 中的多线程编程。
一、什么是多线程?
简单来说,多线程允许程序同时执行多个任务。每个任务运行在不同的线程中,这些线程共享同一个进程的资源。使用多线程可以有效提高程序的执行效率,特别是在处理计算密集型或 I/O 密集型任务时。
打个比方:假设你在厨房做饭,你一个人做饭(单线程)可能需要准备、洗菜、炒菜,然后等米饭煮好才能吃。如果你能请到助手(多线程),一个人洗菜,一个人炒菜,这样两件事情可以同时进行,效率自然会大大提高。
多线程的好处
提高效率:让多个任务并行执行,减少等待时间。
增强用户体验:如在游戏或应用中,可以将耗时操作(比如加载资源)放在后台执行,避免界面卡顿。
多核 CPU 的利用:现代计算机通常是多核的,使用多线程可以充分利用多个 CPU 核心并发执行任务。
二、C++ 中的多线程支持
C++ 在 C++11 标准中引入了 std::thread 类,极大简化了多线程编程。我们可以通过 std::thread 来创建、管理线程,并通过锁机制解决线程之间的数据竞争问题。
- 基本的多线程示例
让我们从一个最基本的例子开始,创建一个新线程并在其中执行一段代码。
#include <iostream>
#include <thread>
// 定义一个简单的函数
void printMessage() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
// 创建并启动线程,执行 printMessage 函数
std::thread t(printMessage);
// 主线程等待子线程执行完毕
t.join();
return 0;
}
代码解释:
std::thread t(printMessage);:创建一个新线程并执行 printMessage 函数。
t.join();:主线程等待子线程执行完毕后再继续。注意:如果不调用 join(),主线程可能会提前结束,从而导致子线程无法正确执行。
- 传递参数给线程
线程不仅可以执行不带参数的函数,还可以传递参数。在 C++ 中,你可以通过简单的值传递或引用传递的方式,向线程函数传递参数。
#include <iostream>
#include <thread>
void printNumber(int n) {
std::cout << "Number from thread: " << n << std::endl;
}
int main() {
int number = 5;
std::thread t(printNumber, number);
t.join();
return 0;
}
代码解释:
std::thread t(printNumber, number);:将 number 传递给线程执行的函数 printNumber。
- 使用 Lambda 表达式创建线程
有时候,为了简单和灵活,可以使用 Lambda 表达式 来直接定义一个线程执行的任务。Lambda 表达式可以捕获外部变量,方便多线程编程。
#include <iostream>
#include <thread>
int main() {
int value = 10;
// 使用 Lambda 表达式创建线程
std::thread t([value]() {
std::cout << "Lambda thread value: " << value << std::endl;
});
t.join();
return 0;
}
代码解释:
std::thread t(value { … });:通过 Lambda 表达式直接在创建线程时定义线程要执行的任务。
- 多线程中的共享数据与同步
多个线程可以共享同一块数据,但这可能导致数据竞争(多个线程同时修改同一个数据导致错误)。为了解决这个问题,我们需要使用**互斥量(mutex)**来保护共享资源。
数据竞争示例(错误示范):
#include <iostream>
#include <thread>
int counter = 0; // 共享数据
void increment(int n) {
for (int i = 0; i < n; ++i) {
++counter; // 每个线程同时修改 counter,可能引发数据竞争
}
}
int main() {
std::thread t1(increment, 1000);
std::thread t2(increment, 1000);
t1.join();
t2.join();
std::cout << "Final counter value: " << counter << std::endl; // 结果可能不正确
return 0;
}
使用互斥量解决数据竞争:
#include <iostream>
#include <thread>
#include <mutex>
int counter = 0; // 共享数据
std::mutex mtx; // 互斥量
void increment(int n) {
for (int i = 0; i < n; ++i) {
std::lock_guard<std::mutex> lock(mtx); // 加锁,保护共享数据
++counter;
}
}
int main() {
std::thread t1(increment, 1000);
std::thread t2(increment, 1000);
t1.join();
t2.join();
std::cout << "Final counter value: " << counter << std::endl;
return 0;
}
代码解释:
std::mutex mtx;:声明一个互斥量,用来保护共享数据。
std::lock_guardstd::mutex lock(mtx);:确保在操作共享数据时,其他线程无法同时访问该数据。
- 线程池的概念
线程池是一种优化多线程程序性能的方式。通过提前创建一组线程并不断复用它们,可以避免频繁地创建和销毁线程,进而提高性能。
尽管 C++ 标准库中没有直接提供线程池的实现,但我们可以自己实现一个简单的线程池。
#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
// 线程池类,用于管理一组线程并执行任务
class ThreadPool {
public:
// 构造函数,创建指定数量的线程
ThreadPool(size_t numThreads);
// 析构函数,确保线程池在销毁时正确停止所有线程
~ThreadPool();
// 将任务添加到任务队列中
void enqueue(std::function<void()> task);
private:
// 工作线程列表
std::vector<std::thread> workers;
// 任务队列,存储要执行的任务
std::queue<std::function<void()>> tasks;
// 互斥量,用于保护任务队列的访问
std::mutex queueMutex;
// 条件变量,用于线程等待任务
std::condition_variable condition;
// 标志位,指示线程池是否停止
bool stop;
// 工作线程执行的函数
void workerThread();
};
// 构造函数,创建 numThreads 个线程并启动
ThreadPool::ThreadPool(size_t numThreads) : stop(false) {
// 启动每个线程,执行 workerThread 函数
for (size_t i = 0; i < numThreads; ++i) {
workers.emplace_back([this] { workerThread(); });
}
}
// 析构函数,等待所有线程执行完毕后销毁
ThreadPool::~ThreadPool() {
{
// 获取互斥锁,设置停止标志位
std::unique_lock<std::mutex> lock(queueMutex);
stop = true;
}
// 通知所有等待的线程
condition.notify_all();
// 等待每个线程完成并加入到主线程中
for (std::thread &worker : workers) {
worker.join();
}
}
// 将新任务添加到任务队列中
void ThreadPool::enqueue(std::function<void()> task) {
{
// 获取互斥锁,保证任务队列操作的线程安全
std::unique_lock<std::mutex> lock(queueMutex);
// 将任务添加到队列中
tasks.push(task);
}
// 通知一个等待的线程去执行新添加的任务
condition.notify_one();
}
// 工作线程执行的函数
void ThreadPool::workerThread() {
while (true) {
std::function<void()> task;
{
// 获取互斥锁,安全访问任务队列
std::unique_lock<std::mutex> lock(queueMutex);
// 等待,直到有任务或线程池被停止
condition.wait(lock, [this] { return stop || !tasks.empty(); });
// 如果线程池停止且任务队列为空,则退出线程
if (stop && tasks.empty()) {
return;
}
// 从任务队列中取出任务
task = std::move(tasks.front());
tasks.pop();
}
// 执行任务
task();
}
}
// 主函数,创建线程池并提交任务
int main() {
ThreadPool pool(4); // 创建一个有 4 个线程的线程池
// 添加 8 个任务到线程池
for (int i = 0; i < 8; ++i) {
pool.enqueue([i] {
std::cout << "Task " << i << " is being processed" << std::endl;
});
}
// 主线程休眠 2 秒,等待任务执行完成
std::this_thread::sleep_for(std::chrono::seconds(2));
return 0;
}
代码解释:
线程池在初始化时创建了一组线程。
enqueue() 方法将任务添加到任务队列中,线程池中的线程会从队列中取出任务并执行。
线程池的好处在于减少了频繁创建和销毁线程的开销,提升了并发执行效率。
三、总结
通过这篇文章,你应该对 C++ 中的多线程编程有了一个全面的理解。从基础的线程创建到使用互斥量保护共享资源,再到实现线程池,C++ 提供了强大而灵活的工具来编写并发程序。
多线程编程的核心是:并发执行、共享资源、同步保护。我们要合理利用线程,同时避免常见的错误,比如数据竞争和死锁。在实际项目中,多线程编程不仅能提升程序的性能,还能带来更好的用户体验。
希望通过本文的学习,你能够在自己的项目中更加自如地使用 C++ 多线程技术!
标签:std,include,int,C++,任务,详解,线程,多线程 From: https://blog.csdn.net/weixin_52734695/article/details/142105937