C++算法
C++高性能计算实战：多线程 SIMD 内存池与并发数据结构
介绍 C++ 高性能计算的核心优化技术，涵盖多线程编程（C++11/14/17）、SIMD 指令集优化、内存池设计及高性能并发数据结构。内容包括性能评估指标与工具、线程池实现、AVX2 数组运算加速、固定与可变大小内存池构建，以及无锁队列和哈希表的 CAS 实现。旨在帮助开发者提升程序吞吐量、降低延迟并优化资源占用。
介绍 C++ 高性能计算的核心优化技术，涵盖多线程编程（C++11/14/17）、SIMD 指令集优化、内存池设计及高性能并发数据结构。内容包括性能评估指标与工具、线程池实现、AVX2 数组运算加速、固定与可变大小内存池构建，以及无锁队列和哈希表的 CAS 实现。旨在帮助开发者提升程序吞吐量、降低延迟并优化资源占用。
C++程序性能瓶颈主要集中在三个层面，优化需针对性突破：
核心优化目标：高吞吐（单位时间处理更多任务）、低延迟（单次任务执行耗时短）、低资源占用（内存/CPU使用率合理）。
C++11引入标准线程库，彻底告别平台相关的 pthread/Win32 线程，C++14/17进一步增强特性，为高性能并发编程提供坚实基础。
std::thread 是C++11线程管理核心类，支持创建线程、等待线程结束、分离线程，需注意线程对象销毁前必须调用 join() 或 detach()。
#include <iostream>
#include <thread>
#include <chrono>
// 线程函数
void thread_func(int num) {
for (int i = 0; i < 3; ++i) {
std::cout << "Thread " << num << " running: " << i << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 休眠 100ms
}
}
int main() {
// 创建线程
std::thread t1(thread_func, 1);
std::thread t2(thread_func, 2);
// 等待线程结束（阻塞主线程）
t1.join();
t2.join();
std::cout << "Main thread exit" << std::endl;
return 0;
}
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
std::mutex mtx;
std::condition_variable cv;
std::queue<int> task_queue;
bool is_running = true;
// 生产者线程
void producer() {
for (int i = 0; i < 5; ++i) {
std::lock_guard<std::mutex> lock(mtx); // 自动加锁/解锁
task_queue.push(i);
std::cout << "Produce task: " << i << std::endl;
cv.notify_one(); // 唤醒一个等待线程
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
}
// 消费者线程
void consumer() {
while (is_running) {
std::unique_lock<std::mutex> lock(mtx); // 等待条件满足（队列非空）
cv.wait(lock, [](){return !task_queue.empty() || !is_running;});
if (!task_queue.empty()) {
task = task_queue.();
task_queue.();
std::cout << << task << std::endl;
}
}
}
{
;
;
prod.();
is_running = ;
cv.();
cons.();
;
}
#include <iostream>
#include <thread>
#include <shared_mutex>
std::shared_timed_mutex rw_mtx;
int shared_data = 0;
// 读线程（共享锁）
void reader(int id) {
std::shared_lock<std::shared_timed_mutex> lock(rw_mtx);
std::cout << "Reader " << id << " read data: " << shared_data << std::endl;
}
// 写线程（独占锁）
void writer() {
std::unique_lock<std::shared_timed_mutex> lock(rw_mtx);
shared_data++;
std::cout << "Writer update data: " << shared_data << std::endl;
}
int main() {
std::thread r1(reader, 1), r2(reader, 2), w(writer), r3(reader, 3);
r1.join();
r2.join();
w.join();
r3.join();
return 0;
}
#include <iostream>
#include <vector>
#include <algorithm>
#include <execution> // C++17 并行算法头文件
#include <thread>
int main() {
// 并行排序（C++17）
std::vector<int> vec(1000000);
std::generate(vec.begin(), vec.end(), [](){return rand()%10000;});
// 并行排序（std::execution::par 表示并行执行）
std::sort(std::execution::par, vec.begin(), vec.end());
// std::jthread 自动 join
std::jthread t([](std::stop_token st){
while(!st.stop_requested()){
std::cout << "Jthread running..." << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
});
std::this_thread::sleep_for(std::chrono::milliseconds(300));
t.request_stop(); // 取消线程
return 0;
}
线程池通过复用线程减少线程创建/销毁开销，是高并发场景核心组件，核心设计要点：任务队列、线程数组、同步机制、拒绝策略。
#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <functional>
#include <atomic>
class ThreadPool {
public:
// 构造函数：初始化线程池
explicit ThreadPool(size_t thread_num = std::thread::hardware_concurrency()) : is_running_(true) {
// 线程数默认设为 CPU 核心数
for (size_t i = 0; i < thread_num; ++i) {
threads_.emplace_back([this]() { this->worker(); });
}
}
// 析构函数：关闭线程池
~ThreadPool() {
{
std::lock_guard<std::mutex> lock(mtx_);
is_running_ = false;
}
cv_.notify_all(); // 唤醒所有工作线程
for (auto& t : threads_) {
if (t.joinable()) {
t.();
}
}
}
{
ReturnType = ((args...));
task = std::make_shared<std::packaged_task<()>>(
std::(std::forward<F>(f), std::forward<Args>(args)...));
std::future<ReturnType> future = task->();
{
;
(!is_running_) {
std::();
}
task_queue_.([task]() { (*task)(); });
}
cv_.();
future;
}
:
{
() {
std::function<()> task;
{
;
cv_.(lock, []() { !is_running_ || !task_queue_.(); });
(!is_running_ && task_queue_.()) {
;
}
task = std::(task_queue_.());
task_queue_.();
}
();
}
}
:
std::vector<std::thread> threads_;
std::queue<std::function<()>> task_queue_;
std::mutex mtx_;
std::condition_variable cv_;
std::atomic<> is_running_;
};
{
;
( i = ; i < ; ++i) {
pool.([i]() {
std::cout << << i << << std::this_thread::() << std::endl;
std::this_thread::(std::chrono::());
});
}
;
}
SIMD（单指令多数据）是 CPU 向量计算技术，通过一条指令并行处理多个数据，大幅提升计算密集型任务性能，主流指令集：SSE（128位）、AVX（256位）、AVX-512（512位）。
SIMD 通过扩展 CPU 寄存器宽度，将多个数据打包到一个向量寄存器中，单次指令完成对所有数据的运算，如 AVX2 寄存器可同时存储 8 个 int32 数据，一次加法指令完成 8 个数据的加法。
编译器提供 SIMD intrinsic 函数（本质是汇编指令的封装），无需直接编写汇编，即可调用 SIMD 指令，常用编译器：GCC/Clang、MSVC。
以'两个 int 数组相加'为例，对比普通实现与 AVX2 优化实现的性能差异。
#include <iostream>
#include <vector>
#include <chrono>
#include <immintrin.h> // AVX2 头文件
// 普通实现：逐元素相加
void add_normal(const std::vector<int>& a, const std::vector<int>& b, std::vector<int>& c) {
for (size_t i = 0; i < a.size(); ++i) {
c[i] = a[i] + b[i];
}
}
// AVX2 优化实现：一次处理 8 个 int（256 位=8×32 位）
void add_avx2(const std::vector<int>& a, const std::vector<int>& b, std::vector<int>& c) {
size_t i = 0;
const size_t batch_size = 8; // AVX2 一次处理 8 个 int
for (; i < a.size() - batch_size + 1; i += batch_size) {
// 加载 8 个 int 到 AVX2 寄存器
__m256i vec_a = _mm256_loadu_si256((__m256i*)&a[i]);
__m256i vec_b = _mm256_loadu_si256((__m256i*)&b[i]);
// 向量加法：8 个 int 同时相加
__m256i vec_c = _mm256_add_epi32(vec_a, vec_b);
// 存储结果到内存
_mm256_storeu_si256((__m256i*)&c[i], vec_c);
}
// 处理剩余元素（不足 8 个）
for (; i < a.(); ++i) {
c[i] = a[i] + b[i];
}
}
{
size = ;
;
start = std::chrono::high_resolution_clock::();
(a, b, c);
end = std::chrono::high_resolution_clock::();
std::cout << << std::chrono::<std::chrono::milliseconds>(end - start).() << << std::endl;
start = std::chrono::high_resolution_clock::();
(a, b, c);
end = std::chrono::high_resolution_clock::();
std::cout << << std::chrono::<std::chrono::milliseconds>(end - start).() << << std::endl;
;
}
编译命令（GCC）：g++ -O3 -mavx2 simd_test.cpp -o simd_test
性能对比：AVX2 优化后性能提升约 3~4 倍（具体取决于 CPU 型号）。
频繁调用 new/delete 会导致内存碎片、性能低下（系统调用开销大），内存池通过预先分配内存块、复用内存，大幅提升内存分配效率，是高性能系统核心组件。
固定大小内存池适合分配大小固定的对象（如链表节点、任务对象），设计简单、性能最优。
#include <iostream>
#include <cstdlib>
#include <cstdint>
class FixedSizeMemoryPool {
public:
// 构造函数：初始化内存池
FixedSizeMemoryPool(size_t block_size, size_t pool_size) : block_size_(align_up(block_size)), pool_size_(pool_size) {
// 计算总内存大小：块大小 × 块数量
total_size_ = block_size_ * pool_size_;
// 分配内存池（从堆上分配连续内存）
pool_start_ = (char*)std::malloc(total_size_);
if (!pool_start_) {
throw std::bad_alloc();
}
// 初始化空闲链表（将所有块串联）
free_list_ = pool_start_;
char* curr = pool_start_;
for (size_t i = 0; i < pool_size_ - 1; ++i) {
// 每个块的头部存储下一个块的地址（空闲时）
*(char**)curr = curr + block_size_;
curr += block_size_;
}
*(char**)curr = nullptr; // 最后一个块的下一个地址为 null
}
// 析构函数：释放内存池
~FixedSizeMemoryPool() {
std::free(pool_start_);
}
// 分配内存块
void* allocate() {
if (!free_list_) {
// 空闲链表为空，可扩容或返回 null（此处简单返回 null）
;
}
* ptr = free_list_;
free_list_ = *(**)free_list_;
ptr;
}
{
(!ptr) ;
(ptr < pool_start_ || ptr >= pool_start_ + total_size_) {
std::();
}
*(**)ptr = free_list_;
free_list_ = (*)ptr;
}
:
{
align = ;
(size + align - ) & ~(align - );
}
:
* pool_start_;
* free_list_;
block_size_;
pool_size_;
total_size_;
};
{
;
* p1 = pool.();
* p2 = pool.();
* p3 = pool.();
* p4 = pool.();
* p5 = pool.();
std::cout << << p1 << << p2 << << p3 << << p4 << << p5 << std::endl;
pool.(p2);
pool.(p4);
* p6 = pool.();
* p7 = pool.();
std::cout << << p6 << << p7 << std::endl;
;
}
可变大小内存池支持分配不同大小的内存块，核心设计：按大小区间划分多个固定大小内存池（如 8B、16B、32B、64B、128B），分配时选择匹配的内存池。
#include <iostream>
#include <vector>
#include <cstdint>
#include <algorithm>
// 固定大小内存池（复用之前的实现）
class FixedSizeMemoryPool {
// ... 此处省略，与 4.2 实现一致 ...
};
class VariableSizeMemoryPool {
public:
VariableSizeMemoryPool() {
// 初始化不同大小的固定内存池：8B、16B、32B、64B、128B，每个池 100 个块
pool_sizes_ = {8, 16, 32, 64, 128};
for (size_t size : pool_sizes_) {
pools_.emplace_back(std::make_unique<FixedSizeMemoryPool>(size, 100));
}
}
// 分配内存
void* allocate(size_t size) {
if (size == 0) return nullptr;
// 找到匹配的内存池（大于等于 size 的最小块大小）
auto it = std::lower_bound(pool_sizes_.begin(), pool_sizes_.end(), size);
if (it == pool_sizes_.end()) {
// 超过最大块大小，直接调用 malloc
return std::malloc(size);
}
pool_size = *it;
pool_idx = it - pool_sizes_.();
* ptr = pools_[pool_idx]->();
(ptr) ptr;
pools_[pool_idx] = std::<FixedSizeMemoryPool>(pool_size, );
pools_[pool_idx]->();
}
{
(!ptr) ;
(size == ) ;
it = std::(pool_sizes_.(), pool_sizes_.(), size);
(it == pool_sizes_.()) {
std::(ptr);
;
}
pool_size = *it;
pool_idx = it - pool_sizes_.();
{
pools_[pool_idx]->(ptr);
} ( std::invalid_argument&) {
std::(ptr);
}
}
:
std::vector<> pool_sizes_;
std::vector<std::unique_ptr<FixedSizeMemoryPool>> pools_;
};
{
VariableSizeMemoryPool pool;
* p1 = pool.();
* p2 = pool.();
* p3 = pool.();
std::cout << << p1 << << p2 << << p3 << std::endl;
pool.(p1, );
pool.(p2, );
pool.(p3, );
;
}
通过分配/释放 100 万个 8 字节对象，对比内存池与 new/delete 的性能：
| 分配方式 | 耗时（ms） | 内存碎片率 |
|---|---|---|
| new/delete | ~80 | ~25% |
| 固定大小内存池 | ~5 | ~5% |
| 可变大小内存池 | ~8 | ~8% |
| 结论：内存池分配效率比 new/delete 提升 10~16 倍，内存碎片率显著降低。 |
多线程环境下，普通数据结构（std::vector、std::queue）非线程安全，直接使用会导致数据竞争，高性能并发数据结构需通过锁优化、无锁编程提升并发效率。
基于 CAS 实现无锁队列（Michael-Scott 队列），适合高并发场景，无锁操作避免上下文切换和锁竞争。
#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
template<typename T>
class LockFreeQueue {
private:
// 队列节点
struct Node {
T data;
std::atomic<Node*> next;
Node(const T& data) : data(data), next(nullptr) {}
};
std::atomic<Node*> head_; // 队列头部
std::atomic<Node*> tail_; // 队列尾部
public:
LockFreeQueue() {
// 哨兵节点（空节点），简化入队/出队逻辑
Node* sentinel = new Node(T());
head_.store(sentinel);
tail_.store(sentinel);
}
~LockFreeQueue() {
// 释放所有节点
while (Node* node = head_.load()) {
head_.store(node->next.load());
delete node;
}
}
// 入队
void enqueue(const T& data) {
Node* new_node = new Node(data);
Node* old_tail = nullptr;
{
old_tail = tail_.();
} (!old_tail->next.(, new_node, std::memory_order_release, std::memory_order_relaxed));
tail_.(old_tail, new_node);
}
{
Node* old_head = ;
Node* new_head = ;
{
old_head = head_.();
new_head = old_head->next.();
(!new_head) {
;
}
data = new_head->data;
} (!head_.(
old_head, new_head, std::memory_order_release, std::memory_order_relaxed));
old_head;
;
}
{
head_.()->next.() == ;
}
};
{
LockFreeQueue<> queue;
task_num = ;
;
std::vector<std::thread> producers;
( i = ; i < ; ++i) {
producers.([&]() {
( j = ; j < task_num; ++j) {
queue.(j);
}
});
}
std::vector<std::thread> consumers;
( i = ; i < ; ++i) {
consumers.([&]() {
data;
(count < task_num * ) {
(queue.(data)) {
count++;
}
}
});
}
(& t : producers) t.();
(& t : consumers) t.();
std::cout << << count << << task_num * << << std::endl;
;
}
无锁哈希表基于 CAS 指令实现，采用链地址法解决哈希冲突，核心优化：分段锁、原子操作保证并发安全。
#include <iostream>
#include <vector>
#include <atomic>
#include <functional>
#include <utility>
template<typename K, typename V, size_t Capacity = 1024>
class LockFreeHashTable {
private:
// 哈希表节点
struct Node {
K key;
V value;
std::atomic<Node*> next;
Node(K key, V value) : key(key), value(value), next(nullptr) {}
};
std::vector<std::atomic<Node*>> table_; // 哈希表数组
std::hash<K> hash_; // 哈希函数
public:
LockFreeHashTable() {
// 初始化哈希表，每个桶为空
table_.resize(Capacity);
for (auto& bucket : table_) {
bucket.store(nullptr);
}
}
~LockFreeHashTable() {
// 释放所有节点
for (size_t i = 0; i < Capacity; ++i) {
Node* node = table_[i].load();
while (node) {
Node* next = node->next.load();
delete node;
node = next;
}
}
}
{
idx = (key) % Capacity;
Node* new_node = (key, value);
Node* old_head = ;
{
old_head = table_[idx].();
new_node->next.(old_head);
} (!table_[idx].(
old_head, new_node, std::memory_order_release, std::memory_order_relaxed));
;
}
{
idx = (key) % Capacity;
Node* node = table_[idx].();
(node) {
(node->key == key) {
value = node->value;
;
}
node = node->next.();
}
;
}
{
idx = (key) % Capacity;
Node* prev = ;
;
}
};
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online