C++ 作为一种高级编程语言，随着计算机硬件的发展，尤其是多核处理器的普及，越来越强调并行编程的能力。并行编程能够有效提升计算速度、提高程序运行效率，从而充分发挥硬件优势。为了支持并行编程，C++ 提供了多种框架和内置功能，本文将对此进行详细介绍。
标准库中的并行编程功能
C++17 及以上版本的标准库提供了多种并行编程功能，其中最重要的包括并行算法、线程、互斥锁和条件变量等。这些功能使编写并行程序变得更加方便和高效。
并行算法
C++17 引入了一系列并行算法，通过在标准库中的算法函数上添加并行执行策略，可以显著提升算法的执行效率。以下是一个简单的示例，展示了如何使用并行执行策略来处理数组的排序。
#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
int main() {
std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
std::sort(std::execution::par, vec.begin(), vec.end());
for (int n : vec) {
std::cout << n << ' ';
}
return 0;
}
在这个例子中，通过将排序算法 std::sort 的执行策略指定为 std::execution::par，可以启用并行排序，从而加快排序过程。
线程
自 C++11 开始，标准库便引入了对线程（thread）的支持，使得多线程编程变得更加方便。以下是一个简单的多线程示例：
#include <iostream>
#include <thread>
void print_message(const std::string &message) {
std::cout << message << std::endl;
}
int main() {
std::thread t1(print_message, "Hello from thread 1");
std::thread t2(print_message, "Hello from thread 2");
t1.join();
t2.join();
return 0;
}
这个示例展示了如何创建线程并将任务分配给线程执行，通过调用 join() 方法确保主线程等待子线程执行完毕。
互斥锁和条件变量
在多线程编程中，经常需要处理线程间的同步问题，以防止资源竞争和数据不一致。C++ 标准库提供了多种同步机制，包括互斥锁（mutex）和条件变量（condition variable）。
互斥锁
互斥锁用于保护共享资源，确保同一时间只有一个线程能够访问资源。以下是一个使用互斥锁的例子：
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
void print_message(const std::string &message) {
std::lock_guard<std::mutex> lock(mtx);
std::cout << message << std::endl;
}
int main() {
std::thread t1(print_message, "Hello from thread 1");
std::thread t2(print_message, "Hello from thread 2");
t1.join();
t2.join();
return 0;
}
在这个示例中，std::lock_guard 用于自动管理互斥锁的加锁和解锁机制，保证了共享资源的安全访问。
条件变量
条件变量用于线程间的等待与通知机制，使线程能够高效地等待某个条件达成。以下是一个简单的示例：
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void print_message() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{ return ready; });
std::cout << "Hello from the worker thread" << std::endl;
}
int main() {
std::thread worker(print_message);
{
std::lock_guard<std::mutex> lock(mtx);
ready = true;
}
cv.notify_one();
worker.join();
return 0;
}
这个示例展示了一个简单的生产者-消费者模型，worker 线程等待 ready 变量变为 true，然后输出消息。主线程则负责设置 ready 变量并通知 worker 线程。
任务调度和线程池
为了更高效地管理线程资源，尤其是在高并发环境下，C++ 标准库引入了任务调度和线程池的概念。虽然标准库本身并未提供直接的线程池实现，但可以通过第三方库（如 Intel TBB）或自己实现线程池来进行高效的任务管理。
#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
class ThreadPool {
public:
ThreadPool(size_t threads);
~ThreadPool();
void enqueue(std::function<void()> task);
private:
std::vector<std::thread> workers;
std::queue<std::function<void()>> tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop;
};
ThreadPool::ThreadPool(size_t threads) : stop(false) {
for (size_t i = 0; i < threads; ++i) {
workers.emplace_back([this] {
while (true) {
std::function<void()> task;
{
std::unique_lock<std::mutex> lock(this->queue_mutex);
this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
if (this->stop && this->tasks.empty())
return;
task = std::move(this->tasks.front());
this->tasks.pop();
}
task();
}
});
}
}
ThreadPool::~ThreadPool() {
{
std::unique_lock<std::mutex> lock(queue_mutex);
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(queue_mutex);
tasks.emplace(task);
}
condition.notify_one();
}
int main() {
ThreadPool pool(4);
for (int i = 0; i < 8; ++i) {
pool.enqueue([i] {
std::cout << "Task " << i << " is being processed" << std::endl;
});
}
std::this_thread::sleep_for(std::chrono::seconds(2));
return 0;
}
这个简单的线程池实现展示了如何创建一个包含多个线程的线程池，并将任务提交到线程池中处理。通过使用线程池，可以更高效地管理线程资源，避免频繁创建和销毁线程带来的开销。
总的来说，C++ 标准库提供了丰富的并行编程功能，从并行算法到线程、互斥锁和条件变量，再到任务调度和线程池，这些工具为开发高效并发程序提供了强有力的支持。掌握这些功能，可以显著提升程序的性能和响应速度。