关于共享_ptr的种族条件示例

Question

https://godbolt.org/z/neypyqdqk”中没有种族条件

#include<memory>
#include<thread>

std::shared_ptr<int> g_s = std::make_shared<int>(1);

void f1(std::shared_ptr<int> sp)
{
    std::shared_ptr<int>l_s1 = sp; // read g_s
}

void f2()
{
    std::shared_ptr<int> l_s2 = std::make_shared<int>(3);
    std::thread th(f1, g_s);
    th.detach();
    g_s = l_s2; // write g_s
}

int main()
{
    std::thread(f2).join();
}

为什么在代码snippet 下面？

#include<memory>
#include<thread>

std::shared_ptr<int> g_s = std::make_shared<int>(1);

void f1(std::shared_ptr<int>& sp)
{
    std::shared_ptr<int>l_s1 = sp; // read g_s
}

void f2()
{
    std::shared_ptr<int> l_s2 = std::make_shared<int>(3);
    std::thread th(f1, std::ref(g_s));
    th.detach();
    g_s = l_s2; // write g_s
}

int main()
{
    std::thread(f2).join();
}

我目前对这个问题的想法是在第一个答案中看到的。但是我还不那么确定。 有人可以阐明这个问题吗？

Answer 1

std :: shardy_ptr 本身不是线程 - safe ）std :: shared_ptr＆lt;＆gt;不能从两个线程同一时间修改。

它不是线程安全的，因为为了速度而言，在共享_ptr＆gt;＆gt;＆gt;＆gt;＆gt;中没有静音。

您的第一个代码片段仅通过共享_ptr＆lt; gt;实例，切勿引用，因此两个线程修改了它们的不同副本。线程安全。

第二个代码段将引用到第二个线程，因此两个线程修改了共享_ptr＆lt; gt;的同一实例这不是线程安全的。

为什么修改共享指针的副本是线程安全的？我们需要研究如何实施。

共享指针由对象的指针本身和指向连接两个计数器的结构的指针组成，一个计数共享指针的参考数量，第二个计数弱指针参考的数量。计数器通常在堆上分配，因此可以在共享指针的几个副本之间共享指向相同堆的计数器的指针。

当制作共享指针的副本时，将堆指向其计数器的堆复制到共享指针的其他副本，而共享指针计数器会增加原子上。

当共享指针的副本被破坏时，其计数器在原子上被减少。如果这是最后的副本，则将计数器从堆中划分。

为什么应在原子上逐渐增加/减少计数器？由于可能构造或破坏其他线程中的其他共享指针的其他副本，因此其他线程会增加/减少计数器。

如果计数器在同一时间上的不同线程上增加/减少，则应在原子上进行，以便将值读取为一个单个操作。这是避免反击本身内的比赛条件所需的。

原子操作通常是在

Answer 2

首先， std :: shared_ptr 确保访问基础控制块是安全的。

对于后一个代码段，可以同时读取并写入不同线程的原始指针和指向控制块的指针，这将构成竞赛。

对于前一个，因为 void f1（std :: shared_ptr＆lt; int; int sp）通过值（即 std :: shared_ptr＆lt; t＆gt; sp ）通过值，读取原始指针和 sp 控制块的指针都独立于将所述指针分配给 g_s 。因此没有数据竞赛条件。

Answer 3

为了帮助想要更好地了解 shared_ptr 的数据竞赛的读者。

此代码代码片段没有任何种族条件：

#include<memory>
#include<thread>

std::shared_ptr<int> g_s = std::make_shared<int>(1);
std::weak_ptr<int> w_p{g_s};

void f1(std::weak_ptr<int>& wp)
{
    std::shared_ptr<int>l_s1 = wp.lock(); // read g_s
}

void f2()
{
    std::shared_ptr<int> l_s2 = std::make_shared<int>(3);
    std::thread th(f1, std::ref(w_p));
    th.detach();
    g_s = l_s2; // write g_s
}

int main()
{
    std::thread(f2).join();
}

此下面的代码段也没有任何种族条件：

#include<memory>
#include<thread>

std::shared_ptr<int> g_s = std::make_shared<int>(1);
std::weak_ptr<int> w_p{g_s};

void f1(std::weak_ptr<int> wp)
{
    std::shared_ptr<int>l_s1 = wp.lock(); // read g_s
}

void f2()
{
    std::shared_ptr<int> l_s2 = std::make_shared<int>(3);
    std::thread th(f1, w_p);
    th.detach();
    g_s = l_s2; // write g_s
}

int main()
{
    std::thread(f2).join();
}

因为 std :: feek_ptr :: feek_ptr :: lock（） 创建一个新的std :: shared_ptr，该shared_ptr共享托管对象的所有权。如果没有托管对象，即 *这是空的，那么返回的shared_ptr也为空。， wp.lock（）返回临时 sharone_ptr ，这与名为 g_s 的一个不同。