C++11 引入的 shared_ptr 智能指针性能对比 Raw 指针怎么样？-51CTO.COM

C++11引入的智能指针（std::shared_ptr、std::unique_ptr、std::weak_ptr）通过自动化资源管理，极大降低了内存泄漏和悬垂指针的风险。

自从C++11智能指针推出后，关于 shared_ptr 的使用，分为了两派，一派认为Raw指针不应该再出现在代码中，另外一派认为要谨慎使用 shared_ptr, 大多数时候还是要使用Raw指针更合理。

这里我们不讨论者两派谁正确，关注的是 shared_ptr 的性能。

shared_ptr 提供了很多便利，但是这种便利性并非没有代价——尤其是 std::shared_ptr，其性能开销在特定场景下可能成为瓶颈。

一、智能指针性能开销的核心来源

1. 原子操作与引用计数

std::shared_ptr 的核心机制是引用计数，其实现依赖于原子操作。每次拷贝或销毁 shared_ptr 时，引用计数（use_count）和弱引用计数（weak_count）都需要通过原子指令进行增减。

原子操作虽然保证了线程安全，但其代价显著：　

原子指令的硬件支持：现代CPU通过锁缓存行（Cache Line Locking）或总线锁（Bus Locking）实现原子性。例如，x86架构的LOCK前缀指令会强制独占缓存行，导致流水线停顿。

内存屏障（Memory Barrier）：原子操作通常伴随内存屏障，确保多核间的数据一致性。这会抑制编译器和CPU的指令重排优化，增加指令周期。

示例：引用计数的原子增减　

// 伪代码：shared_ptr拷贝构造时的原子操作
ControlBlock* ctrl = ptr.control_block;
atomic_increment(&ctrl->use_count);  // 原子递增

2. 控制块的内存开销

每个 shared_ptr 实例需要维护一个控制块（Control Block），包含：　

引用计数（use_count）
弱引用计数（weak_count）
删除器（Deleter）
分配器（Allocator）

控制块通常通过动态内存分配（如new）创建，其大小在64位系统下约为40字节（具体因实现而异）。频繁创建 shared_ptr 会导致堆内存碎片化，同时增加缓存未命中的概率。　

3. 间接访问与缓存局部性

shared_ptr的实际对象指针和控制块指针通常是分离的。访问对象时，需要先加载控制块指针，再通过控制块访问对象。这种两级间接访问破坏了数据的空间局部性，导致CPU缓存效率降低。　

对比：原始指针 vs. shared_ptr　

// 原始指针：直接访问
int* raw = new int(42);
int value = *raw;  // 一次内存访问

// shared_ptr：间接访问
std::shared_ptr<int> shared = std::make_shared<int>(42);
int value = *shared;  // 先访问控制块，再访问对象（可能两次内存访问）

二、量化性能开销：基准测试与分析

1. 单线程环境下的开销

通过对比shared_ptr、unique_ptr和原始指针的操作耗时，可以直观量化性能差异。　

测试代码片段（使用Google Benchmark）：　

static voidBM_RawPtr(benchmark::State& state){
    for (auto _ : state) {
        int* p = newint(42);
        delete p;
    }
}
BENCHMARK(BM_RawPtr);

staticvoidBM_UniquePtr(benchmark::State& state){
    for (auto _ : state) {
        auto p = std::make_unique<int>(42);
    }
}
BENCHMARK(BM_UniquePtr);

staticvoidBM_SharedPtr(benchmark::State& state){
    for (auto _ : state) {
        auto p = std::make_shared<int>(42);
    }
}
BENCHMARK(BM_SharedPtr);

结果（x86-64, GCC 12.2, -O2优化）：　

操作	耗时（ns/op）
Raw Pointer	15
std::unique_ptr	16
std::shared_ptr	45

结论：shared_ptr的构造/析构开销是原始指针的3倍，主要来自控制块分配和原子操作。　

2. 多线程环境下的争用（Contention）

当多个线程频繁操作同一shared_ptr时，原子操作的缓存一致性协议（如MESI）会导致严重的性能下降。　

测试场景：　

10个线程并发增加/减少shared_ptr的引用计数。

对比无争用（每个线程操作独立shared_ptr）和高争用（所有线程操作同一shared_ptr）。

结果（AMD EPYC 7763, 64核）：　

场景	吞吐量（ops/ms）
无争用	1,200,000
高争用	12,000

结论：高争用下性能下降100倍，原子操作的缓存行乒乓（Cache Line Ping-Pong）是主因。（当多个线程频繁更新某一缓存行中的数据时，缓存系统可能需要不断地将数据从一个核心的缓存同步到另一个核心的缓存，这个过程就像乒乓球一样在缓存之间来回传递，导致性能降低）

三、底层机制：从C++标准到硬件架构

1. 原子操作的实现细节

C++标准要求 shared_ptr 的引用计数操作是线程安全的，因此编译器会生成特定的原子指令。以x86-64为例：　

atomic_increment对应LOCK XADD指令。

LOCK XADD 是原子加法和交换指令。它会确保在多个处理器核心之间同步操作，避免数据竞争。
std::shared_ptr 的引用计数增加时，会使用这种指令

atomic_decrement对应LOCK SUB指令。

LOCK SUB 是带锁的减法指令，保证了引用计数的减少操作是原子的，防止多个线程同时修改引用计数时发生竞态条件。

2. 控制块的内存布局

典型的shared_ptr控制块布局（以libstdc++实现为例）：　

struct ControlBlock {
    std::atomic<long> use_count;  // 8字节
    std::atomic<long> weak_count; // 8字节
    Deleter* deleter;             // 8字节
    Allocator* allocator;         // 8字节
    void* object_ptr;             // 8字节
};

总大小：40字节（64位系统）。若对象较小（如int），控制块的内存开销可能超过对象本身。　

3. 缓存局部性的影响

现代CPU的L1缓存行通常为64字节。若 shared_ptr 的控制块和对象分散存储，访问对象时可能需要加载两个不同的缓存行，导致吞吐量下降。　

优化示例：std::make_shared将对象和控制块分配在连续内存中，提高缓存局部性：　

auto p = std::make_shared<int>(42);  // 对象和控制块单次分配
auto q = std::shared_ptr<int>(new int(42));  // 两次分配（对象+控制块）

四、实际场景中的性能问题案例

1. 游戏引擎中的实体管理

某游戏引擎使用 shared_pt r管理游戏实体（Entity），每个实体包含多个组件（Component）。在每秒60帧的更新频率下，频繁的 shared_ptr 拷贝导致CPU耗时增加15%。

优化方案：　

改用std::unique_ptr + 手动生命周期管理。

使用对象池（Object Pool）减少动态分配。

2. 高频交易系统的消息传递

一个高频交易系统使用 shared_ptr 传递市场数据消息。在峰值负载下，原子操作的争用导致延迟从2微秒飙升至50微秒。

优化方案：　

改用无锁（Lock-Free）数据结构和原始指针。

使用线程局部存储（TLS）避免跨线程争用。

3. 分布式系统的节点通信

某分布式系统使用 shared_ptr 管理网络连接对象。在10,000个并发连接下，控制块内存占用超过1GB。

优化方案：　

使用std::weak_ptr替代非拥有性引用。

自定义删除器复用控制块内存。

五、优化策略与实践

1. 优先使用std::unique_ptr

适用场景：独占所有权，无需共享。

优势：零额外开销，性能等同原始指针。

示例：

auto resource = std::make_unique<DatabaseConnection>();
transfer_ownership(std::move(resource));  // 显式所有权转移

2. 减少 shared_ptr 的拷贝

使用const&传递：避免不必要的引用计数增减。

void process(const std::shared_ptr<Data>& data) { /* ... */ }

移动语义：用std::move转移所有权。

auto p1 = std::make_shared<int>(42);
auto p2 = std::move(p1);  // 无原子操作

3. 控制块分配优化

使用std::make_shared：合并对象和控制块的内存分配。

auto p = std::make_shared<Object>(args);  // 推荐
auto q = std::shared_ptr<Object>(new Object(args));  // 不推荐

4. 避免多线程争用

线程局部存储（TLS）：为每个线程分配独立shared_ptr。

thread_local std::shared_ptr<Cache> local_cache = create_cache();

总结

原始指针：性能更高，因为没有引用计数和线程安全管理的开销，但缺乏自动内存管理和线程安全，容易导致内存泄漏或多线程错误。

shared_ptr：提供了自动内存管理和线程安全，但有一定的性能开销，尤其是在引用计数操作和多线程环境下。