std::shared_ptr 线程安全

如何解决std::shared_ptr 线程安全

在多线程程序中使用共享指针 (std::shared_ptr) 是否安全？
我不考虑对共享指针拥有的数据的读/写访问，而是考虑共享指针本身。

我知道某些实现（例如 MSDN）确实提供了这种额外的保证；但我想了解这是否由标准保证，因此是可移植的。

#include <thread>
#include <memory>
#include <iostream>

void function_to_run_thread(std::shared_ptr<int> x)
{
    std::cout << x << "\n";
}
// Shared pointer goes out of scope.
// Is its destruction here guaranteed to happen only once?
// Or is this a "Data Race" situation that is UB?

int main()
{
    std::thread   threads[2];

    {
        // A new scope
        // So that the shared_ptr in this scope has the
        // potential to go out of scope before the threads have executed.
        // So leaving the shared_ptr in the scope of the threads only.
        std::shared_ptr<int>   data = std::make_shared<int>(5);

        // Create workers.
        threads[0] = std::thread(function_to_run_thread,data);
        threads[1] = std::thread(function_to_run_thread,data);
    }
    threads[0].join();
    threads[1].join();
}

任何指向标准部分的链接都是最受欢迎的。

如果人们能参考主要实现，我会很高兴，这样我们就可以认为它对大多数普通开发人员来说是可移植的。

MSDN：检查。线程安全。
G++：？
叮当声：？

我会考虑这些主要实现，但很乐意考虑其他实现。

解决方法

我没有标准的链接。我很久以前确实检查过，std::shared_ptr 在某些条件下是线程安全的，总结为：每个线程都应该有自己的副本。如 cppreference 所述：

所有成员函数（包括复制构造函数和复制赋值）都可以在 shared_ptr 的不同实例上被多个线程调用，无需额外同步，即使这些实例是副本并共享同一对象的所有权。如果多个执行线程在没有同步的情况下访问同一个 shared_ptr，并且这些访问中的任何一个使用了 shared_ptr 的非常量成员函数，那么就会发生数据竞争。

所以就像标准中的任何其他类一样，允许从多个线程读取同一个实例。不是从 1 个线程写入此实例。

int main()
{
    std::vector<std::thread>   threads;

    {
        // A new scope
        // So that the shared_ptr in this scope has the
        // potential to go out of scope before the threads have executed.
        // So leaving the shared_ptr in the scope of the threads only.
        std::shared_ptr<int>   data = std::make_shared<int>(5);

        // Perfectly legal to read access the shared_ptr
        threads.emplace_back(std::thread([&data]{ std::cout << data.get() << '\n'; }));        
        threads.emplace_back(std::thread([&data]{ std::cout << data.get() << '\n'; }));

        // This line will result in a race condition as you now have read and write on the same instance
        threads.emplace_back(std::thread([&data]{ data = std::make_shared<int>(42); }));

        for (auto &thread : threads)
           thread.join();
    }
}

一旦我们处理了 shared_ptr 的多个副本，一切都很好：

int main()
{
    std::vector<std::thread>   threads;

    {
        // A new scope
        // So that the shared_ptr in this scope has the
        // potential to go out of scope before the threads have executed.
        // So leaving the shared_ptr in the scope of the threads only.
        std::shared_ptr<int>   data = std::make_shared<int>(5);

        // Perfectly legal to read access the shared_ptr copy
        threads.emplace_back(std::thread([data]{ std::cout << data.get() << '\n'; }));        
        threads.emplace_back(std::thread([data]{ std::cout << data.get() << '\n'; }));

        // This line will no longer result in a race condition the other threads are using a copy
        threads.emplace_back(std::thread([&data]{ data = std::make_shared<int>(42); }));

        for (auto &thread : threads)
           thread.join();
    }
}

也可以销毁 shared_ptr ，因为每个线程都会调用本地 shared_ptr 的析构函数，最后一个将清理数据。对引用计数有一些原子操作以确保正确发生。

int main()
{
    std::vector<std::thread>   threads;

    {
        // A new scope
        // So that the shared_ptr in this scope has the
        // potential to go out of scope before the threads have executed.
        // So leaving the shared_ptr in the scope of the threads only.
        std::shared_ptr<int>   data = std::make_shared<int>(5);

        // Perfectly legal to read access the shared_ptr copy
        threads.emplace_back(std::thread([data]{ std::cout << data.get() << '\n'; }));        
        threads.emplace_back(std::thread([data]{ std::cout << data.get() << '\n'; }));

        // Sleep to ensure we have some delay
        threads.emplace_back(std::thread([data]{ std::this_thread::sleep_for(std::chrono::seconds{2}); }));
    }
    for (auto &thread : threads)
       thread.join();
}

正如您已经指出的，对 shared_ptr 中数据的访问不受保护。与第一种情况类似，如果您有 1 个线程读取和 1 个线程写入，您仍然有问题。这可以通过原子或互斥体或通过保证对象的只读性来解决。

引用 latest draft：

为了确定是否存在数据竞争，成员函数应仅访问和修改 shared_ptr 和 weak_ptr 对象本身，而不是它们所引用的对象。 use_count() 中的更改不反映可能引入数据竞争的修改。

所以，这里有很多东西需要考虑。第一句话谈到了不访问指针对象的成员函数，即访问指针对象不是线程安全的。

然而，还有第二句话。实际上，这强制任何会改变 use_count() 的操作（例如复制构造、赋值、销毁、调用 reset）是线程安全的——但仅限于它们影响 use_count()。

这是有道理的：复制同一个 std::shared_ptr（或销毁同一个 std::shared_ptr）的不同线程不得导致有关指针对象所有权的数据竞争。 use_count() 的内部值必须同步。

我查了一下，N3337第 20.7.2.2 节第 4 段中也有这个确切的措辞，所以可以肯定地说，自从在C++11（后来没有介绍）。

shared_ptr（以及weak_ptr）利用原子整数来保持使用计数，因此线程之间的共享是安全的，但当然，对数据的访问仍然需要互斥锁或任何其他同步。

std::shared_ptr 线程安全

如何解决std::shared_ptr 线程安全

解决方法

相关推荐