智能指针的线程安全性 ​

面试考点 ​

这道题考察你对 shared_ptr 线程安全保证的精确理解。很多人以为 shared_ptr 是"线程安全的"就可以随便跨线程用,实际上它只有引用计数的操作是原子的,指向对象的访问和 shared_ptr 对象本身的读写并不是线程安全的。

核心概念 ​

shared_ptr 的线程安全性分三个层次:

层次是否线程安全说明
引用计数操作是(原子操作)多个 shared_ptr 副本可在不同线程安全地拷贝/销毁
shared_ptr 对象本身否同一个 shared_ptr 对象不能被多线程同时读写
指向的对象否需要用户自己做同步保护

基本示例 ​

cpp
#include <iostream>
#include <memory>
#include <thread>
#include <mutex>
#include <vector>
#include <atomic>

// ============================
// 示例1:引用计数是线程安全的
// ============================

void ref_count_safe_demo() {
    auto sp = std::make_shared<int>(42);

    // 在不同线程中拷贝/销毁 shared_ptr 是安全的
    // 因为引用计数用原子操作维护
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; i++) {
        threads.emplace_back([sp]() {
            // 每个线程持有自己的 shared_ptr 副本
            // 拷贝构造时引用计数原子递增
            auto local_copy = sp;
            std::cout << "线程 use_count: " << local_copy.use_count() << std::endl;
            // 析构时引用计数原子递减
        });
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "最终 use_count: " << sp.use_count() << std::endl;  // 1
}

// ============================
// 示例2:shared_ptr 对象本身不是线程安全的
// ============================

void shared_ptr_object_unsafe_demo() {
    auto sp = std::make_shared<int>(0);

    // 错误:多个线程同时读写同一个 shared_ptr 对象
    // 下面的代码是数据竞争(未定义行为)
    /*
    std::thread t1([&sp]() {
        sp = std::make_shared<int>(1);  // 写 sp
    });
    std::thread t2([&sp]() {
        auto local = sp;  // 读 sp(同时 t1 在写)
    });
    t1.join();
    t2.join();
    */

    // 正确做法1:用 mutex 保护
    std::mutex mtx;
    std::vector<std::thread> threads;

    for (int i = 0; i < 5; i++) {
        threads.emplace_back([&sp, &mtx, i]() {
            std::lock_guard<std::mutex> lock(mtx);
            sp = std::make_shared<int>(i);  // 受 mutex 保护
        });
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "最终值: " << *sp << std::endl;
}

// ============================
// 示例3:C++20 atomic<shared_ptr>
// ============================

/*
// C++20 提供了 std::atomic<std::shared_ptr<T>>
// 让 shared_ptr 对象本身的操作变成原子的

void atomic_shared_ptr_demo() {
    std::atomic<std::shared_ptr<int>> asp = std::make_shared<int>(0);

    std::thread t1([&asp]() {
        asp.store(std::make_shared<int>(1));  // 原子写
    });
    std::thread t2([&asp]() {
        auto local = asp.load();  // 原子读
        std::cout << "读到: " << *local << std::endl;
    });

    t1.join();
    t2.join();
}
*/

// ============================
// 示例4:指向对象的访问需要保护
// ============================

class Counter {
    int count_ = 0;
    mutable std::mutex mutex_;
public:
    // 线程安全的递增
    void increment() {
        std::lock_guard<std::mutex> lock(mutex_);
        count_++;
    }

    int get() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return count_;
    }
};

void pointed_object_demo() {
    // 即使多个线程持有各自的 shared_ptr 副本
    // 它们指向同一个对象
    // 对象本身的访问需要同步
    auto counter = std::make_shared<Counter>();

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; i++) {
        threads.emplace_back([counter]() {
            for (int j = 0; j < 1000; j++) {
                counter->increment();  // Counter 内部有 mutex 保护
            }
        });
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "计数器: " << counter->get() << std::endl;  // 10000
}

// ============================
// 示例5:unique_ptr 的线程安全性
// ============================

void unique_ptr_thread_demo() {
    // unique_ptr 独占所有权,通常不跨线程共享
    // 但可以通过 std::move 转移所有权到另一个线程
    auto up = std::make_unique<int>(42);

    std::thread t([p = std::move(up)]() {
        // p 在这个线程中独占
        std::cout << "线程中的值: " << *p << std::endl;
    });

    // up 已经被移走,此处为空
    // std::cout << *up;  // 未定义行为!

    t.join();
}

// ============================
// 示例6:weak_ptr 的线程安全性
// ============================

void weak_ptr_thread_demo() {
    auto sp = std::make_shared<int>(42);
    std::weak_ptr<int> wp = sp;

    std::thread t([wp]() {
        // lock() 是线程安全的
        // 它原子地检查引用计数并创建 shared_ptr
        if (auto locked = wp.lock()) {
            std::cout << "weak_ptr 锁定成功: " << *locked << std::endl;
        } else {
            std::cout << "对象已销毁" << std::endl;
        }
    });

    t.join();
}

int main() {
    std::cout << "=== 引用计数安全 ===" << std::endl;
    ref_count_safe_demo();

    std::cout << "\n=== shared_ptr 对象本身 ===" << std::endl;
    shared_ptr_object_unsafe_demo();

    std::cout << "\n=== 指向对象的访问 ===" << std::endl;
    pointed_object_demo();

    std::cout << "\n=== unique_ptr ===" << std::endl;
    unique_ptr_thread_demo();

    std::cout << "\n=== weak_ptr ===" << std::endl;
    weak_ptr_thread_demo();

    return 0;
}

智能指针线程安全总结 ​

智能指针引用计数指针对象本身指向的对象
shared_ptr原子安全不安全(需 mutex 或 C++20 atomic)不安全(需用户同步)
unique_ptr无引用计数不跨线程共享不安全
weak_ptr原子安全不安全lock() 是线程安全的

常见问题 ​

多个线程同时读同一个 shared_ptr 安全吗?

安全。多个线程同时读(即拷贝)同一个 shared_ptr 是安全的。但如果有线程在写(reset、赋值),就需要同步。

make_shared 和 new 有什么区别?

make_shared<T>(args) 一次分配内存(对象和控制块放一起),效率更高。shared_ptr<T>(new T(args)) 两次分配。在多线程环境下 make_shared 还能避免某些异常安全问题。

C++20 的 atomic<shared_ptr> 解决了什么问题?

解决了"同一个 shared_ptr 对象被多线程同时读写"的问题。之前需要用 mutex 保护,现在可以用 atomic 接口(load、store、compare_exchange)。

适用场景 ​

  • 多线程共享资源的所有权管理
  • 观察者模式(weak_ptr 防止循环引用)
  • 异步回调中延长对象生命周期
  • 线程间传递数据的所有权

注意事项 ​

  • 不要多线程同时读写同一个 shared_ptr 对象
  • 指向的对象需要用户自己保证线程安全
  • weak_ptr::lock() 是线程安全的原子操作
  • C++20 提供 atomic<shared_ptr> 解决对象级原子性
  • make_shared 比 new + shared_ptr 更安全更高效

总结 ​

shared_ptr 的线程安全性是有限的:引用计数操作是原子的(多个副本可在不同线程安全拷贝/销毁),但 shared_ptr 对象本身和它指向的对象都不是线程安全的。面试中要能清楚地分出三个层次:引用计数(安全)、指针对象本身(不安全)、指向的对象(不安全)。C++20 的 atomic<shared_ptr> 解决了第二层的问题,第三层始终需要用户自己同步。