哈喽，各位好！今天咱们聊点硬核的，关于C++中的“Thread-per-Core”架构，也就是“每个核心一个线程”的并发模型。这玩意儿，说白了，就是为了榨干CPU的最后一滴性能，让你的程序跑得飞起。
啥是Thread-per-Core？
简单来说，就是你的程序里有多少个CPU核心，你就创建多少个线程。每个线程绑定到一个特定的核心上，然后让它们各司其职，并行运算。
想象一下，你家厨房有四个炉灶（核心），你请了四个厨师（线程），每个厨师负责一道菜。这样是不是比一个厨师跑来跑去，效率高多了？这就是Thread-per-Core的精髓。
为啥要用Thread-per-Core？
- 减少上下文切换： 线程切换是很费时间的。CPU需要在不同的线程之间保存和恢复状态，这被称为上下文切换。Thread-per-Core架构可以减少线程切换，因为线程基本一直在自己的核心上跑，不用频繁换地方。
- 更好地利用缓存： CPU有L1、L2、L3等多级缓存。如果一个线程一直在一个核心上跑，它可以充分利用该核心上的缓存，减少对内存的访问，提高效率。
- 避免伪共享（False Sharing）： 多个线程访问同一缓存行上的不同变量时，即使这些变量逻辑上不相关，也会导致缓存一致性问题，降低性能。Thread-per-Core可以减少这种情况的发生，因为线程之间的数据共享更少。
- 真正的并行： 在多核CPU上，只有让多个线程同时运行，才能真正实现并行计算，发挥CPU的全部潜力。
啥时候用Thread-per-Core？
Thread-per-Core不是万能的，它也有适用场景。
- CPU密集型任务： 比如图像处理、科学计算、大规模数据处理等，这些任务需要大量的CPU运算，使用Thread-per-Core可以显著提高性能。
- 对性能要求极高的应用： 比如游戏引擎、高性能服务器等，这些应用需要尽可能地榨干CPU的性能。
- 任务之间相对独立： 如果任务之间有大量的依赖关系，需要频繁的同步和通信，那么Thread-per-Core可能反而会降低性能。
Thread-per-Core的实现
C++11提供了强大的线程库，可以方便地实现Thread-per-Core架构。
-
获取CPU核心数量：
#include <iostream> #include <thread> int main() { unsigned int num_threads = std::thread::hardware_concurrency(); std::cout << "CPU核心数量: " << num_threads << std::endl; return 0; }std::thread::hardware_concurrency()函数可以获取CPU的核心数量。注意，这个函数返回的是建议的线程数量，并不一定是实际的物理核心数。在一些超线程（Hyper-Threading）的CPU上，一个物理核心可以模拟成两个逻辑核心。 -
创建线程并绑定到核心：
在Linux系统下，可以使用
pthread_setaffinity_np函数将线程绑定到指定的CPU核心。#define _GNU_SOURCE #include <iostream> #include <thread> #include <sched.h> #include <pthread.h> #include <unistd.h> void worker_thread(int core_id) { cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(core_id, &cpuset); pthread_t current_thread = pthread_self(); int rc = pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset); if (rc != 0) { std::cerr << "Error setting thread affinity: " << rc << std::endl; return; } std::cout << "线程 " << std::this_thread::get_id() << " 绑定到核心 " << core_id << std::endl; // 在这里执行你的CPU密集型任务 for (int i = 0; i < 100000000; ++i) { // 模拟一些计算 double result = i * 3.1415926; } std::cout << "线程 " << std::this_thread::get_id() << " 完成任务" << std::endl; } int main() { unsigned int num_threads = std::thread::hardware_concurrency(); std::cout << "CPU核心数量: " << num_threads << std::endl; std::vector<std::thread> threads; for (unsigned int i = 0; i < num_threads; ++i) { threads.emplace_back(worker_thread, i); } for (auto& thread : threads) { thread.join(); } std::cout << "所有线程完成" << std::endl; return 0; }这段代码创建了
num_threads个线程，并将每个线程绑定到一个不同的CPU核心上。pthread_setaffinity_np函数的第一个参数是线程ID，第二个参数是CPU核心集合的大小，第三个参数是CPU核心集合。CPU_ZERO宏用于清空CPU核心集合，CPU_SET宏用于将指定的CPU核心添加到集合中。注意： Windows系统下，可以使用
SetThreadAffinityMask函数来实现线程绑定。具体用法可以查阅MSDN文档。 -
任务分配：
将任务分配给不同的线程是Thread-per-Core架构的关键。任务分配的方式有很多种，常见的有：
- 静态分配： 在程序启动时，将任务分配给不同的线程，之后不再改变。
- 动态分配： 使用任务队列，线程从队列中获取任务并执行。
下面是一个使用任务队列的例子：
#include <iostream> #include <thread> #include <vector> #include <queue> #include <mutex> #include <condition_variable> #include <functional> class ThreadPool { public: ThreadPool(size_t num_threads) : stop(false) { threads.resize(num_threads); for (size_t i = 0; i < num_threads; ++i) { threads[i] = std::thread([this, i]() { cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(i, &cpuset); pthread_t current_thread = pthread_self(); int rc = pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset); if (rc != 0) { std::cerr << "Error setting thread affinity for thread " << i << ": " << rc << std::endl; return; } std::cout << "Thread " << std::this_thread::get_id() << " bound to core " << i << std::endl; while (true) { std::function<void()> task; { std::unique_lock<std::mutex> lock(queue_mutex); cv.wait(lock, [this]() { return stop || !tasks.empty(); }); if (stop && tasks.empty()) { return; } task = tasks.front(); tasks.pop(); } task(); } }); } } ~ThreadPool() { { std::unique_lock<std::mutex> lock(queue_mutex); stop = true; } cv.notify_all(); for (std::thread& thread : threads) { thread.join(); } } template<typename F> void enqueue(F f) { { std::unique_lock<std::mutex> lock(queue_mutex); tasks.emplace(f); } cv.notify_one(); } private: std::vector<std::thread> threads; std::queue<std::function<void()>> tasks; std::mutex queue_mutex; std::condition_variable cv; bool stop; }; int main() { unsigned int num_threads = std::thread::hardware_concurrency(); ThreadPool pool(num_threads); for (int i = 0; i < 20; ++i) { pool.enqueue([i]() { std::cout << "Task " << i << " started by thread " << std::this_thread::get_id() << std::endl; // 模拟一些计算 for (int j = 0; j < 10000000; ++j) { double result = j * 2.71828; } std::cout << "Task " << i << " finished by thread " << std::this_thread::get_id() << std::endl; }); } // 等待所有任务完成 std::this_thread::sleep_for(std::chrono::seconds(5)); return 0; }这个例子创建了一个线程池，线程池中的每个线程都绑定到一个CPU核心上。任务被添加到任务队列中，线程从队列中获取任务并执行。
Thread-per-Core的注意事项
- 线程数量： 线程数量应该等于CPU的核心数量，而不是逻辑核心数量。如果线程数量超过核心数量，反而会增加上下文切换的开销，降低性能。
- 任务划分： 任务应该被划分成大小合适的块。如果任务太小，线程创建和同步的开销可能会超过任务本身的计算量。如果任务太大，可能会导致负载不均衡，某些核心空闲，而某些核心负载过高。
- 数据共享： 尽量减少线程之间的数据共享。如果必须共享数据，可以使用锁、原子操作等同步机制来保证数据的一致性。
- 缓存一致性： 注意缓存一致性问题，避免伪共享。可以使用数据对齐、填充等技术来解决伪共享问题。
- NUMA架构： 如果你的系统是NUMA（Non-Uniform Memory Access）架构，需要注意线程和内存的分配。尽量将线程和其访问的数据分配到同一个NUMA节点上，以减少内存访问延迟。
Thread-per-Core的优缺点
| 优点 | 缺点 |
|---|---|
| 充分利用CPU资源 | 并非所有问题都适合使用Thread-per-Core。例如，I/O密集型任务可能更适合使用异步I/O或其他并发模型。 |
| 减少上下文切换 | 需要仔细考虑任务划分和数据共享，不当的设计可能会导致性能下降。 |
| 提高缓存命中率 | 线程数量与CPU核心数量绑定，如果核心数量较少，可能无法充分利用所有资源。 |
| 更容易实现真正的并行 | 线程绑定到核心增加了代码的复杂性，需要更深入地了解底层硬件。 |
| 避免伪共享(前提是精心设计数据结构和访问模式) | 某些操作系统或硬件平台可能对线程绑定有额外的限制或要求。 |
总结
Thread-per-Core是一种强大的并发模型，可以显著提高CPU密集型任务的性能。但是，它也有一定的复杂性，需要仔细考虑任务划分、数据共享、缓存一致性等问题。只有在合适的场景下，才能发挥Thread-per-Core的最大威力。
一些补充说明
-
超线程（Hyper-Threading）：
超线程技术允许一个物理核心模拟成两个逻辑核心。虽然超线程可以提高CPU的利用率，但它并不能真正地将CPU性能翻倍。因此，在使用Thread-per-Core架构时，应该将线程数量设置为物理核心的数量，而不是逻辑核心的数量。
-
NUMA（Non-Uniform Memory Access）：
NUMA架构的系统中，CPU和内存之间的访问延迟是不均匀的。每个CPU都有自己的本地内存，访问本地内存的速度比访问其他CPU的内存要快得多。因此，在使用Thread-per-Core架构时，应该尽量将线程和其访问的数据分配到同一个NUMA节点上，以减少内存访问延迟。
-
性能测试：
在实际应用中，需要进行性能测试，才能确定Thread-per-Core架构是否真的能够提高性能。可以使用一些性能测试工具，比如
perf、valgrind等，来分析程序的性能瓶颈。
希望今天的分享能帮到大家，让你们的程序跑得更快更稳！咱们下期再见！