前言
随着计算机硬件的不断升级，多核处理器已成为现代计算机的标配。而并行编程技术则成为了充分利用多核处理器的关键。C++11 中新增的并行编程库，使得 C++ 语言在并行编程方面具有了更为强大的能力。
本篇文章将介绍 C++11 并行编程的基本概念和使用方法，并探究一些优化方法，以帮助读者更好地理解并行编程的本质和优化技巧。
基本概念
C++11 并行编程库主要包括以下几个部分：
std::thread：线程库，用于创建和控制线程。std::mutex：互斥量库，用于保护共享数据的访问。std::condition_variable：条件变量库，用于线程间的通信。std::future和std::promise：异步编程库，用于异步执行任务并获取结果。
在并行编程中，常常需要使用多个线程同时执行某个任务，并在任务完成后将结果合并。这种情况下，需要保证多个线程之间的数据访问不会发生冲突，否则会导致数据不一致等问题。因此，需要使用互斥量和条件变量来保护共享数据的访问。
异步编程则是指将一个任务放到一个线程中执行，同时在主线程中继续执行其他任务，等到异步任务完成后再获取结果。异步编程可以提高程序的响应速度，同时也可以充分利用多核处理器的能力。
使用方法
创建线程
使用 std::thread 类创建线程非常简单，只需要传入一个函数指针或可调用对象即可：
#include <iostream>
#include <thread>
void hello() {
std::cout << "Hello, World!" << std::endl;
}
int main() {
std::thread t(hello);
t.join(); // 等待线程结束
return 0;
}上面的代码中，我们定义了一个 hello 函数，然后使用 std::thread 类创建一个线程 t，并将 hello 函数作为线程的入口点。最后使用 join 函数等待线程结束。
保护共享数据的访问
在多线程编程中，需要保证多个线程之间的数据访问不会发生冲突。为此，需要使用互斥量来保护共享数据的访问。
以下是一个简单的例子，演示如何使用互斥量来保护共享数据的访问：
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 互斥量
void increment(int& x) {
for (int i = 0; i < 1000000; ++i) {
std::lock_guard<std::mutex> lock(mtx); // 使用互斥量保护共享数据的访问
++x;
}
}
int main() {
int x = 0;
std::thread t1(increment, std::ref(x));
std::thread t2(increment, std::ref(x));
t1.join();
t2.join();
std::cout << "x = " << x << std::endl;
return 0;
}上面的代码中，我们定义了一个互斥量 mtx，然后在 increment 函数中使用 std::lock_guard 类来保护共享数据 x 的访问。std::lock_guard 类是一个 RAII（资源获取即初始化）类，用于在作用域结束时自动释放互斥量。
在 main 函数中，我们创建了两个线程 t1 和 t2，并将共享数据 x 的引用作为参数传入。最后使用 join 函数等待线程结束，并输出 x 的值。
线程间的通信
在多线程编程中，常常需要使用条件变量来实现线程间的通信。条件变量可以用于等待某个条件的发生，或者通知其他线程某个条件的发生。
以下是一个简单的例子，演示如何使用条件变量实现线程间的通信：
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx; // 互斥量
std::condition_variable cv; // 条件变量
bool ready = false;
void worker() {
std::unique_lock<std::mutex> lock(mtx);
while (!ready) {
cv.wait(lock); // 等待条件变量
}
std::cout << "Worker is working..." << std::endl;
}
int main() {
std::thread t(worker);
std::this_thread::sleep_for(std::chrono::seconds(3));
{
std::lock_guard<std::mutex> lock(mtx);
ready = true;
}
cv.notify_one(); // 通知条件变量
t.join();
return 0;
}上面的代码中，我们定义了一个互斥量 mtx 和一个条件变量 cv，然后在 worker 函数中使用 std::unique_lock 类来锁定互斥量，并使用 cv.wait 函数等待条件变量的发生。在 main 函数中，我们创建了一个线程 t，并在 3 秒后设置 ready 为 true，然后使用 cv.notify_one 函数通知条件变量的发生。最后使用 join 函数等待线程结束。
异步编程
异步编程可以使用 std::future 和 std::promise 类来实现。std::future 类表示一个异步操作的结果，std::promise 类则用于异步执行任务并设置结果。
以下是一个简单的例子，演示如何使用 std::future 和 std::promise 类实现异步编程：
#include <iostream>
#include <future>
int add(int a, int b) {
return a + b;
}
int main() {
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread t([&p]() {
p.set_value(add(1, 2));
});
std::cout << "1 + 2 = " << f.get() << std::endl;
t.join();
return 0;
}上面的代码中，我们创建了一个 std::promise 对象 p，并使用 get_future 函数获取一个 std::future 对象 f。然后在一个新的线程中异步执行 add 函数，并将结果设置为 p 的值。在主线程中，我们使用 f.get 函数获取异步操作的结果。最后使用 join 函数等待线程结束。
优化方法
并行算法
并行算法是指能够在多个线程中同时执行的算法。C++11 中提供了一些常用的并行算法，如 std::for_each、std::transform、std::reduce 等。
以下是一个简单的例子，演示如何使用并行算法加速一个向量的计算：
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <chrono>
int main() {
std::vector<double> v(10000000, 1.0);
auto start = std::chrono::high_resolution_clock::now();
std::for_each(std::execution::par, v.begin(), v.end(), [](double& x) {
x = std::sin(x);
});
auto end = std::chrono::high_resolution_clock::now();
std::cout << "Time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms" << std::endl;
double sum = std::reduce(std::execution::par, v.begin(), v.end());
std::cout << "Sum: " << sum << std::endl;
return 0;
}上面的代码中，我们创建了一个包含 10000000 个元素的向量 v，然后使用 std::for_each 函数对向量中的每个元素求正弦值，并使用并行执行策略 std::execution::par 实现并行计算。最后使用 std::reduce 函数对向量中的所有元素求和，并使用并行执行策略 std::execution::par 实现并行计算。最后输出计算结果和时间。
数据局部性优化
数据局部性是指程序访问数据的局部性质，即程序访问的数据通常是连续的或者离得很近的。数据局部性优化可以提高程序的性能，特别是在多核处理器上。
以下是一个简单的例子，演示如何使用数据局部性优化加速矩阵乘法的计算：
#include <iostream>
#include <vector>
#include <chrono>
const int N = 1000;
void matmul(const std::vector<std::vector<double>>& a, const std::vector<std::vector<double>>& b, std::vector<std::vector<double>>& c) {
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
double sum = 0;
for (int k = 0; k < N; ++k) {
sum += a[i][k] * b[k][j];
}
c[i][j] = sum;
}
}
}
void matmul_opt(const std::vector<std::vector<double>>& a, const std::vector<std::vector<double>>& b, std::vector<std::vector<double>>& c) {
for (int i = 0; i < N; ++i) {
for (int k = 0; k < N; ++k) {
for (int j = 0; j < N; ++j) {
c[i][j] += a[i][k] * b[k][j];
}
}
}
}
int main() {
std::vector<std::vector<double>> a(N, std::vector<double>(N, 1.0));
std::vector<std::vector<double>> b(N, std::vector<double>(N, 1.0));
std::vector<std::vector<double>> c(N, std::vector<double>(N, 0.0));
auto start = std::chrono::high_resolution_clock::now();
matmul(a, b, c);
auto end = std::chrono::high_resolution_clock::now();
std::cout << "Time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms" << std::endl;
start = std::chrono::high_resolution_clock::now();
matmul_opt(a, b, c);
end = std::chrono::high_resolution_clock::now();
std::cout << "Time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms" << std::endl;
return 0;
}上面的代码中，我们定义了两个矩阵 a 和 b，并分别使用两种算法 matmul 和 matmul_opt 计算它们的乘积。其中 matmul 算法按照矩阵乘法的定义计算，而 matmul_opt 算法则使用数据局部性优化，将矩阵 a 中的一行和矩阵 b 中的一列存储在同一块内存中，以提高数据局部性。最后输出两种算法的计算时间。
总结
本篇文章介绍了 C++11 并行编程的基本概念和使用方法，并探究了一些优化方法，包括并行算法和数据局部性优化。并行编程可以充分利用多核处理器的能力，提高程序的性能。同时，需要注意保护共享数据的访问和线程间的通信，以避免发生数据不一致等问题。
来源：JavaScript中文网 ，转载请注明来源 本文地址：https://www.javascriptcn.com/post/65c1f55eadd4f0e0ffbf2ad9