1. 项目概述为什么C并行算法是性能优化的“核武器”如果你写过C并且处理过数据量稍微大一点的计算任务比如处理几百万条日志、渲染一帧复杂的图像或者训练一个小型模型你一定对“等待”这件事深有体会。看着进度条慢悠悠地往前爬CPU占用率却只有可怜的25%在一个四核机器上那种感觉就像开着一辆八缸跑车却堵在早高峰的二环路上。问题出在哪很可能你的程序还在用单线程“吭哧吭哧”地干活。这就是我们今天要深入探讨的核心C并行算法。它不是C11/17标准里一个锦上添花的小功能而是一套能让你程序性能原地起飞的“核武器”级工具。简单来说它允许你告诉标准库里的算法比如sort、transform、reduce“嘿别光用一个核算了把我给你的数据分一分让所有CPU核心一起上” 编译器和你使用的标准库实现如GCC搭配Intel TBB会帮你处理好线程创建、任务划分、负载均衡和结果合并这些脏活累活。我见过太多项目在性能遇到瓶颈时团队的第一反应是上更复杂的架构或者换更“快”的语言。但往往瓶颈就出在最基础的循环和数据处理上。学会使用并行算法意味着你能用最小的改动成本榨干现有硬件的最后一滴性能。这不仅仅是“快一点”在数据科学、游戏引擎、高频交易等领域这直接决定了产品的可行性与竞争力。接下来我将拆解掌握这套工具的7个核心技巧它们是我在多年高性能计算项目中从踩坑到熟练应用的经验结晶。2. 核心技巧一理解并行策略选对“发动机”模式C17在execution头文件中引入了执行策略Execution Policies这是你使用并行算法的“总开关”。理解这三个策略的区别是写出正确、高效并行代码的第一步。它们决定了算法以何种方式“并行”。2.1 三种执行策略的深度解析std::execution::seq(顺序执行)是什么这是默认策略也是C17之前所有算法的行为。它强制算法以单线程、顺序的方式执行不进行任何并行化。为什么用它听起来和“并行”背道而驰但它有两个关键用途。第一作为性能基准。在优化前先用seq跑一遍记录时间再与其他策略对比量化你的性能提升。第二用于调试。并行程序的bug如数据竞争难以复现先用seq模式运行如果问题消失那问题很可能就出在并发访问上。代码示例std::sort(std::execution::seq, vec.begin(), vec.end());这行代码和std::sort(vec.begin(), vec.end());完全等价。std::execution::par(并行执行)是什么允许算法在多线程上并行执行。这是你最常用的“主力”策略。库实现会创建线程池将数据分块交给不同线程处理。关键约束它保证在单个线程内元素访问是确定顺序的并且不同线程处理的元素区间不会重叠。这意味着只要你传递给算法的函数对象如lambda是线程安全的不修改共享状态使用par就是安全的。生活类比就像让一个小组的工人线程一起粉刷一堵长墙每个工人负责一段连续的墙面数据块工人之间不会越界但各自工作的先后顺序不确定。代码示例std::for_each(std::execution::par, vec.begin(), vec.end(), [](auto x){ x.process(); });std::execution::par_unseq(并行且向量化执行)是什么这是“狂暴模式”。它不仅允许跨线程并行还允许在单个线程内进行向量化SIMD。SIMD可以让CPU用一条指令同时处理多个数据比如一次对4个float做加法。最强约束它施加了最严格的要求。你传递给算法的函数对象可调用实体必须不仅是线程安全的还不能有向量化不安全的操作例如内存分配/释放new/delete,malloc/free互斥锁操作mutex.lock()/unlock()使用volatile变量任何可能抛出异常且未被当前函数捕获的操作为什么这么严因为编译器/CPU为了进行向量化优化可能会重排、交错执行指令。如果函数里有上述操作这种重排会导致未定义行为。何时使用当你的操作是纯粹的、无副作用的数值计算如数组逐元素相加、相乘且数据量巨大时par_unseq能带来最大化的性能提升同时利用多核和多数据通路。2.2 策略选择决策树与避坑指南面对一个算法如何选择可以遵循这个简单的决策流程开始 | v 你的函数对象是否无状态、无副作用、无锁、无内存分配 |是 |否 v v 考虑 par_unseq 考虑 par | | v v 性能测试验证加速比 性能测试验证正确性 | | v v 使用 par_unseq 使用 par实操心得从par开始除非你非常确定你的操作是向量化友好的否则总是先使用std::execution::par。它是安全性和性能的良好平衡点。警惕隐式共享即使你用了par如果lambda捕获了引用并且修改了外部变量依然会导致数据竞争。这是新手最容易掉进的坑。// 错误示例数据竞争 int sum 0; std::for_each(std::execution::par, vec.begin(), vec.end(), [sum](int x){ sum x; }); // 多个线程同时读写 sum结果不可预测。验证结果并行算法可能会因为任务划分和调度导致操作执行的顺序与seq不同。只要算法本身如加法、比较满足结合律/交换律最终结果就是正确的。但对于依赖顺序的操作如某些依赖前一个元素状态的变换就不能直接并行化。3. 核心技巧二掌握关键并行算法从“for循环”解放C标准库中超过70个算法支持执行策略。你不需要全部记住但必须熟练掌握几个最常用、收益最高的。它们能直接替换掉你代码中那些耗时的显式循环。3.1 四大金刚for_each,transform,reduce,sortstd::for_each并行化的“万能循环”作用对范围内每个元素应用一个函数。这是将传统for循环并行化的最直接工具。典型场景初始化数组、批量修改对象状态、执行一系列独立操作。示例并行地为图像每个像素应用一个滤镜。std::vectorPixel image loadImage(); auto applySepia [](Pixel p) { /* 复杂的棕褐色调计算 */ }; std::for_each(std::execution::par, image.begin(), image.end(), applySepia);std::transform并行化的“映射”函数作用将输入范围的每个元素通过函数转换结果输出到另一个范围或原位。这是函数式编程中的map操作。典型场景数据类型转换、数值计算如归一化、从一组对象中提取属性。示例并行地将一组温度值从摄氏度转换为华氏度。std::vectordouble celsius getTemperatures(); std::vectordouble fahrenheit(celsius.size()); std::transform(std::execution::par, celsius.begin(), celsius.end(), fahrenheit.begin(), [](double c) { return c * 9.0/5.0 32; });std::reduce与std::accumulate并行化的“聚合”操作核心区别accumulate是顺序的reduce是并行友好的。reduce不保证操作顺序因此要求操作满足结合律如加法、乘法、求最大值。作用将范围中的所有元素合并成一个值如求和、求积、找极值。典型场景计算数组总和、平均值、寻找最大/最小值。示例并行计算一个大型向量的点积。std::vectordouble a getVectorA(); std::vectordouble b getVectorB(); // 先通过 transform 计算对应元素乘积再用 reduce 求和 std::vectordouble products(a.size()); std::transform(std::execution::par, a.begin(), a.end(), b.begin(), products.begin(), std::multipliesdouble()); double dotProduct std::reduce(std::execution::par, products.begin(), products.end()); // C17 更优雅的写法如果编译器支持 // double dotProduct std::transform_reduce(std::execution::par, // a.begin(), a.end(), b.begin(), 0.0);std::sort并行化的排序作用对范围进行排序。并行排序是性能提升最明显的场景之一。注意并行排序的内部算法可能与串行版本不同例如可能采用并行样本排序因此对于完全相同的输入seq和par产生的元素交换顺序可能不同但排序结果升序/降序是一致的。示例对百万级用户数据按ID排序。std::vectorUser users loadMillionUsers(); std::sort(std::execution::par, users.begin(), users.end(), [](const User a, const User b) { return a.id b.id; });3.2 算法选择速查表你的需求串行算法 (C98/11)并行算法 (C17)关键注意事项遍历并操作元素for_eachfor_each(execution::par, ...)确保函数对象线程安全无数据竞争转换数据生成新序列transformtransform(execution::par, ...)输入输出迭代器不能重叠除非是原位转换求和、求积、找最值accumulatereduce(execution::par, ...)操作必须满足结合律初值类型可能影响精度排序sortsort(execution::par, ...)比较函数必须是“严格弱序”线程安全查找元素findfind(execution::par, ...)返回第一个找到的元素但“第一个”是任一线程找到的某个元素计数countcount(execution::par, ...)无特殊要求结果与顺序无关注意find的并行版本返回的是任意一个匹配的元素而不一定是顺序上的第一个。如果你的逻辑依赖“第一个”这个语义就不能直接使用并行find。4. 核心技巧三规避数据竞争与死锁编写安全的并行代码并行算法帮你管理线程但不保证你的代码逻辑是线程安全的。数据竞争Data Race是并行编程的头号杀手。4.1 识别与修复典型的数据竞争模式场景使用std::for_each并行修改共享容器。// 危险代码向共享vector中并行插入元素 std::vectorint shared_vec; std::mutex vec_mutex; // 试图用锁保护 std::for_each(std::execution::par, data.begin(), data.end(), [shared_vec, vec_mutex](int x) { std::lock_guardstd::mutex lock(vec_mutex); shared_vec.push_back(x); // 仍然危险 });问题std::vector的push_back在内部可能导致重新分配内存这会使得其他线程持有的迭代器或引用失效。即使有互斥锁保护push_back调用本身但vector的size()、capacity()等查询操作可能在其他线程无锁进行导致读取到不一致的中间状态。解决方案预分配空间如果知道最终大小提前reserve好。使用本地结果合并每个线程先处理到本地容器最后再合并。使用std::atomic如果只是修改一个简单的标量如计数器。使用并行算法本身的归约能力对于求和类操作用reduce而不是自己累加。修正后的安全模式// 方案1预分配 原子索引 std::vectorint result(data.size()); std::atomicsize_t index{0}; std::for_each(std::execution::par, data.begin(), data.end(), [result, index](int x) { size_t i index.fetch_add(1, std::memory_order_relaxed); result[i] x * x; // 写入独立位置安全 }); // 方案2每个线程局部存储最后合并更通用 unsigned int num_threads std::thread::hardware_concurrency(); std::vectorstd::vectorint local_results(num_threads); std::for_each(std::execution::par, data.begin(), data.end(), [local_results](int x) { // 获取当前线程的ID近似 auto thread_id std::hashstd::thread::id{}(std::this_thread::get_id()) % num_threads; local_results[thread_id].push_back(process(x)); }); // 串行合并 local_results 到最终结果4.2 理解内存序与原子操作当你确实需要共享一个简单的状态如计数器、标志位时必须使用std::atomic。std::atomicint counter{0}; std::for_each(std::execution::par, vec.begin(), vec.end(), [counter](auto item) { if (item.isValid()) { counter.fetch_add(1, std::memory_order_relaxed); } });fetch_add是原子的不会发生数据竞争。std::memory_order_relaxed表示只保证原子性不提供额外的同步语义。对于简单的计数器这通常足够了性能最好。如果需要更强的顺序保证如作为某个操作完成的标志则需要memory_order_release/acquire。死锁在并行算法中相对少见因为算法内部通常不会让你去管理锁。但如果你在传递给算法的函数对象中手动加锁并且锁了多个互斥量死锁风险就出现了。务必使用std::lock或std::scoped_lock(C17) 来一次性锁定多个互斥量避免死锁。// 错误可能死锁 std::mutex mtx1, mtx2; std::for_each(std::execution::par, ..., [](auto x){ std::lock_guardstd::mutex lk1(mtx1); std::lock_guardstd::mutex lk2(mtx2); // 如果另一个线程以相反顺序锁则死锁 // ... 操作共享数据 ... }); // 正确使用 scoped_lock 一次性锁定避免死锁 std::for_each(std::execution::par, ..., [](auto x){ std::scoped_lock lk(mtx1, mtx2); // C17自动避免死锁 // ... 操作共享数据 ... });5. 核心技巧四性能调优与负载均衡实战开了并行程序不一定就变快。错误的用法甚至会导致性能下降。性能调优的关键在于减少同步开销和保证负载均衡。5.1 粒度控制别把芝麻拆成八瓣问题如果每个任务的计算量极小比如只是给一个整数加1那么创建线程、调度任务、同步结果的开销会远远超过计算本身导致并行版本比串行还慢。// 错误示例任务粒度过细 std::vectorint tiny_vec(100); // 只有100个元素 std::for_each(std::execution::par, tiny_vec.begin(), tiny_vec.end(), [](int n) { n 1; }); // 开销 收益解决方案批量处理将小任务组合成“块”Chunk。并行算法库内部通常有自动的块划分策略但对于非常小的循环最好手动合并。const size_t chunk_size 1000; for (size_t i 0; i tiny_vec.size(); i chunk_size) { auto end std::min(i chunk_size, tiny_vec.size()); std::for_each(std::execution::par, tiny_vec.begin()i, tiny_vec.begin()end, [](int n) { n 1; }); }经验法则一个并行任务的计算量至少应该在1毫秒以上才能有效掩盖线程管理的开销。对于纳秒级的操作坚决用串行。5.2 负载均衡让所有核心都“忙起来”理想情况下所有CPU核心应该在算法执行期间保持高利用率。负载不均衡通常由两个原因导致数据分布不均某些数据块处理起来比其他块慢得多。外部资源争用任务在等待I/O、锁、或者内存带宽。对于数据分布不均现代并行算法库如Intel TBB通常采用“工作窃取”Work Stealing调度器能一定程度上缓解问题。但最好的办法是设计均匀的任务。对于资源争用需要分析瓶颈内存带宽瓶颈如果所有线程都在疯狂读写内存总带宽可能成为瓶颈。此时增加线程数反而会降低性能。解决方案包括优化数据布局提高缓存命中率、使用更高效的数据结构、或者减少不必要的数据搬运。锁竞争如果并行任务内部有大量锁操作线程会频繁等待。解决方法是减少锁的粒度、使用无锁数据结构、或者用原子操作替代锁。性能分析工具是你的朋友在Linux下可以使用perf查看缓存命中率和CPU周期分布在Windows下可以使用Visual Studio的性能探查器。关注CPU Usage、Cache Misses和Lock Contention这些指标。5.3 测量与验证没有测量就没有优化永远不要“感觉”并行更快要用数据说话。#include chrono #include iostream auto start_seq std::chrono::high_resolution_clock::now(); std::sort(std::execution::seq, data.begin(), data.end()); auto end_seq std::chrono::high_resolution_clock::now(); auto start_par std::chrono::high_resolution_clock::now(); std::sort(std::execution::par, data.begin(), data.end()); auto end_par std::chrono::high_resolution_clock::now(); auto seq_duration std::chrono::duration_caststd::chrono::milliseconds(end_seq - start_seq); auto par_duration std::chrono::duration_caststd::chrono::milliseconds(end_par - start_par); std::cout Sequential sort: seq_duration.count() ms\n; std::cout Parallel sort: par_duration.count() ms\n; std::cout Speedup: static_castdouble(seq_duration.count()) / par_duration.count() x\n;注意第一次运行并行算法可能会有额外开销如线程池初始化。为了公平比较可以运行多次如10次取平均值并确保测试数据足够大。6. 核心技巧五环境搭建、编译与调试的“脏活累活”理论再好跑不起来也是白搭。C并行算法需要编译器和运行时库的支持这是实践中第一个拦路虎。6.1 编译器与依赖库配置GCC ( 9.0)目前对C17并行算法支持最完善。需要链接 Intel Threading Building Blocks (TBB) 库。Clang ( 10.0)通过libc和TBB也提供了较好支持但某些版本可能需要额外配置。MSVC (Visual Studio 2019 16.10)在/std:clatest模式下并链接tbb.lib也提供了支持。以Ubuntu GCC为例的详细配置步骤# 1. 安装GCC-9或更高版本及TBB开发库 sudo apt-get update sudo apt-get install gcc-9 g-9 libtbb-dev # 2. 确认编译器版本 g-9 --version # 3. 编译你的程序必须指定C17标准并链接TBB g-9 -stdc17 -O3 -marchnative -o my_parallel_program my_parallel_program.cpp -ltbb # 4. 运行 ./my_parallel_program-stdc17启用C17特性包括execution头文件。-ltbb链接Intel TBB库这是并行算法的运行时依赖。-O3 -marchnative启用高级优化并针对当前CPU架构生成最佳指令集对向量化很重要。在CMake项目中集成cmake_minimum_required(VERSION 3.10) project(MyParallelProject) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 查找TBB库 find_package(TBB REQUIRED) add_executable(my_app main.cpp) target_link_libraries(my_app PUBLIC TBB::tbb)6.2 调试并行程序的特殊技巧并行程序的bug如数据竞争、死锁具有非确定性可能十次只出现一次让调试极其痛苦。使用seq策略复现首先将执行策略改为std::execution::seq。如果bug消失了那几乎可以断定是并发问题。** sanitizer 工具**这是最强大的武器。AddressSanitizer (ASan)检测内存错误越界、释放后使用。ThreadSanitizer (TSan)专门检测数据竞争。这是调试数据竞争的黄金标准。# 使用GCC/Clang编译时加入TSan g-9 -stdc17 -fsanitizethread -g -O1 -o my_program_tsan my_program.cpp -ltbb # 运行程序TSan会在发现数据竞争时打印详细的报告 ./my_program_tsanTSan的报告会明确指出哪些内存地址被多个线程同时访问以及访问的代码位置。日志与断言在关键区域添加日志但注意日志输出本身也可能引入同步问题导致bug消失即“海森堡bug”。使用原子计数器或线程本地存储来记录事件顺序。简化与隔离尝试创建一个最小的、可复现问题的测试用例。移除不相关的代码往往能更快定位问题。7. 核心技巧六超越标准库与异步任务和线程池协同并行算法适合处理数据并行的“批处理”任务。但在真实项目中你可能会遇到更复杂的场景需要并行执行多个不同类型的、可能产生结果的任务。这时需要将并行算法与std::async,std::future和自定义线程池结合起来。7.1 使用std::async包装并行算法块想象一个场景你需要并行处理多个独立的大文件每个文件内部又需要用并行算法处理。#include future #include vector #include string std::vectordouble processFile(const std::string filename) { auto data loadDataFromFile(filename); std::vectordouble results(data.size()); // 使用并行算法处理单个文件内部数据 std::transform(std::execution::par, data.begin(), data.end(), results.begin(), complexCalculation); return results; } int main() { std::vectorstd::string fileList {data1.bin, data2.bin, data3.bin}; std::vectorstd::futurestd::vectordouble futures; // 启动异步任务处理每个文件粗粒度并行 for (const auto file : fileList) { futures.push_back(std::async(std::launch::async, processFile, file)); } // 收集所有结果 std::vectorstd::vectordouble allResults; for (auto fut : futures) { allResults.push_back(fut.get()); // 等待每个任务完成 } // 进一步合并 allResults... return 0; }这里形成了两级并行外层通过std::async实现任务级并行每个文件一个任务内层通过std::transform(execution::par)实现数据级并行处理单个文件的数据。注意不要创建过多外层任务不要超过CPU核心数太多否则会因任务切换开销过大而降低性能。7.2 与线程池模式集成对于需要处理大量短期、同质任务的场景如Web服务器请求使用std::async每次创建新线程开销太大。更好的模式是使用一个线程池。你可以自己实现也可以使用第三方库如Intel TBB的task_group或Boost.Asio的io_context。思路是将你的并行算法任务包装成一个函数对象提交到线程池的任务队列中。线程池中的工作线程会从队列中取出任务执行。这避免了频繁创建销毁线程的开销。一个简化的概念示例// 假设有一个简单的 ThreadPool 类有 submit() 方法 ThreadPool pool(std::thread::hardware_concurrency()); std::vectorstd::futurevoid futures; for (auto chunk : dataChunks) { // 将数据手动分成块 futures.push_back(pool.submit([chunk]() { // 在这个块上运行一个并行算法 std::sort(std::execution::par, chunk.begin(), chunk.end()); })); } // 等待所有块排序完成 for (auto fut : futures) { fut.get(); } // 然后可能需要一个归并排序的合并步骤这种模式给了你更大的控制权比如可以控制任务粒度、优先级或者处理有依赖关系的任务链。8. 核心技巧七实战案例剖析——并行图像卷积滤波器让我们用一个完整的、贴近实际的例子来串联所有技巧实现一个并行的图像卷积滤波器比如高斯模糊。这是图像处理中的常见操作计算密集非常适合并行化。8.1 问题定义与串行实现假设我们有一个灰度图像表示为一个二维std::vectorfloat以及一个小的卷积核例如3x3的高斯核。卷积操作是每个输出像素是其周围像素与核的加权和。串行实现朴素版std::vectorfloat applyFilterSerial(const std::vectorfloat input, int width, int height, const std::vectorfloat kernel, int kSize) { std::vectorfloat output(width * height, 0.0f); int kRadius kSize / 2; for (int y 0; y height; y) { for (int x 0; x width; x) { float sum 0.0f; for (int ky -kRadius; ky kRadius; ky) { for (int kx -kRadius; kx kRadius; kx) { int ix x kx; int iy y ky; // 处理边界这里采用复制边缘像素 ix std::clamp(ix, 0, width - 1); iy std::clamp(iy, 0, height - 1); float pixel input[iy * width ix]; float weight kernel[(ky kRadius) * kSize (kx kRadius)]; sum pixel * weight; } } output[y * width x] sum; } } return output; }这个四重循环是典型的计算密集型任务也是并行化的绝佳目标。8.2 并行化改造与优化我们的目标是并行化最外层的行循环。使用std::for_each配合par策略。第一版并行实现std::vectorfloat applyFilterParallel(const std::vectorfloat input, int width, int height, const std::vectorfloat kernel, int kSize) { std::vectorfloat output(width * height, 0.0f); int kRadius kSize / 2; // 将行索引包装到一个可迭代的容器中例如iota_view或简单的vector std::vectorint rows(height); std::iota(rows.begin(), rows.end(), 0); // 生成 0, 1, 2, ..., height-1 std::for_each(std::execution::par, rows.begin(), rows.end(), [](int y) { for (int x 0; x width; x) { float sum 0.0f; for (int ky -kRadius; ky kRadius; ky) { for (int kx -kRadius; kx kRadius; kx) { int ix x kx; int iy y ky; ix std::clamp(ix, 0, width - 1); iy std::clamp(iy, 0, height - 1); float pixel input[iy * width ix]; float weight kernel[(ky kRadius) * kSize (kx kRadius)]; sum pixel * weight; } } output[y * width x] sum; } }); return output; }分析正确性每个线程处理不同的行y写入output中不同的位置没有数据竞争。性能粒度合适一行像素的计算量足够大。负载均衡良好每行计算量相同。可优化点边界处理内层循环的std::clamp调用在边界像素上会有一些开销。可以考虑将图像分成内部区域和边界区域分别处理。内存访问input[iy * width ix]是随机访问对缓存不友好。但对于卷积这类算法这是固有的问题。可以尝试使用平铺Tiling技术来优化缓存局部性但这超出了简单并行算法的范畴通常需要手动SIMD或专用库如OpenCV。8.3 性能对比与问题排查用一张1024x1024的图片和3x3核测试int main() { int width 1024, height 1024; std::vectorfloat image(width * height); std::generate(image.begin(), image.end(), [](){ return rand() / (float)RAND_MAX; }); std::vectorfloat kernel {1,2,1,2,4,2,1,2,1}; // 3x3 近似高斯核 float sum std::accumulate(kernel.begin(), kernel.end(), 0.0f); for (auto k : kernel) k / sum; // 归一化 // 测试串行版本 auto start std::chrono::high_resolution_clock::now(); auto result_serial applyFilterSerial(image, width, height, kernel, 3); auto end std::chrono::high_resolution_clock::now(); auto serial_time std::chrono::duration_caststd::chrono::milliseconds(end - start).count(); // 测试并行版本 start std::chrono::high_resolution_clock::now(); auto result_parallel applyFilterParallel(image, width, height, kernel, 3); end std::chrono::high_resolution_clock::now(); auto parallel_time std::chrono::duration_caststd::chrono::milliseconds(end - start).count(); // 验证结果一致性允许浮点误差 bool correct true; for (size_t i 0; i result_serial.size(); i) { if (std::abs(result_serial[i] - result_parallel[i]) 1e-5) { correct false; break; } } std::cout Serial time: serial_time ms\n; std::cout Parallel time: parallel_time ms\n; std::cout Speedup: (double)serial_time / parallel_time x\n; std::cout Results match: (correct ? YES : NO) std::endl; return 0; }在我的6核12线程的机器上这个简单的改造带来了接近4倍的加速比。这已经是非常显著的提升。如果使用par_unseq并确保编译器能对内部循环进行向量化性能还可能进一步提升。踩坑记录第一次实现时我错误地在lambda中捕获了input和output的引用但函数参数是值传递的临时对象导致悬垂引用。务必注意lambda捕获的生命周期。早期版本我尝试对x循环也进行并行化二维并行结果因为任务粒度过细和同步开销性能反而下降。并行不是越多越好找到合适的并行维度是关键。掌握这7个核心技巧你就能在C并发编程的世界里从“能用”走向“精通”。记住并行化的第一步永远是测量最后一步永远是验证。在追求性能的同时绝不能牺牲程序的正确性。现在打开你的IDE找一个计算密集的循环用std::for_each(std::execution::par, ...)试试看吧性能的提升可能会让你大吃一惊。