对 std::atomic::load 的结果使用结构取消引用 (->) 运算符是否安全

Question

在尝试使用 std 原子指针时，我运行进入了以下内容。假设我这样做：

std::atomic<std::string*> myString;
// <do fancy stuff with the string... also on other threads>

//A can I do this?
myString.load()->size()

//B can I do this?
char myFifthChar = *(myString.load()->c_str() + 5);

//C can I do this?
char myCharArray[255];
strcpy(myCharArray, myString.load()->c_str());

我很确定 C 是非法的，因为 myString 可能同时被删除。

但是我不确定 A 和 B。我认为它们是非法的，因为在执行读取操作时指针可能会被引用。

但是如果是这种情况，你怎么能从一个可能被删除的原子指针中读取。由于加载1步，读取数据1步

Answer 1

// A can I do this?
myString.load()->size()

是的，你可以，但如果其他东西可能发生变异或 destructing/deallocating string string myString 你获得了积分。换句话说，原子检索指针后的情况与多个线程可能具有指针的任何 std::string 对象相同，除了...

存在原子 load 是否保证某些特定 construction/change 到 string 的问题 - 可能由更新 myString 以指向特定的任何线程执行string 您 load 指向的实例 - 将对您可见。默认是确保这一点，但您可能希望将 memory_order 参数的 read over this explanation 改为 load()。请注意 not 显式请求内存同步确实 not 让您免受其他线程 mutating/destruction 的影响。

所以，假设 myString() 依次指向 string 的 a、b 然后 c，您的代码检索 &b...只要 string b 在您调用 size() 时没有发生突变或 destructed/deallocated，就可以了。 myString() 可能更新为指向 c before/during/after 你对 b 的 .size().

的调用并不重要

退一步说，程序可能很难知道在您调用 load() 之后多长时间您可能会尝试解除对指针的引用，以及 b 对象是否稍后要突变或 destructed/deallocated，您建议的那种调用不会在稍后 mutation/destruction 周围的任何同步中合作。您显然可以通过多种方式添加此类协调（例如，一些其他原子 counter/flag，使用条件变量通知可能的 modifier/destructor/deleter...），或者您有时可能会决定接受这样的竞争条件（例如，如果已知 b 是大容量 LRU 缓存中的最新条目之一）。

如果你正在做一些像 myString 围绕 static const string 个实例的循环，你不必担心上面的所有 mutation/destruction 东西（好吧，不是除非你正在访问它们 before/after main()).

// B can I do this?
char myFifthChar = *(myString.load()->c_str() + 5);

是的，有上述所有注意事项。

// C can I do this?
char myCharArray[255];
strcpy(myCharArray, myString.load()->c_str());

是，如上所述（前提是提供的缓冲区足够大）。

I'm pretty sure C is illegal because myString might be deleted in the meantime.

如上所述 - 这种担忧对于您提到的所有 3 种用途同样有效，只是 C 更有可能因为复制需要更多 CPU 周期才能完成，而不是让垃圾值丢失race 可能导致缓冲区溢出。

Answer 2

I'm pretty sure C is illegal because myString might be deleted in the meantime.

您的所有示例也是如此。由于原子负载，唯一安全的是负载本身——仅此而已。您有责任确保对所加载内容进行的任何后续操作的安全。而在这种情况下，有none，所以非常不安全。

从原子指针加载的唯一方法是确保您拥有结果，例如 std::shared_ptr<T>，或者保证它的生命周期更长和你应该禁止所有的写作。

Answer 3

如果另一个线程可能会修改或删除 string 对象，则所有这些都是非法的。

atomic 的使用同步了对指针的访问，但是您没有做任何事情来同步对它指向的对象的访问。

Answer 4

有人提到您的方法是有风险的。以下是您可能需要考虑的事项：使用具有不可变值的 std::shared_ptr<const std::string>，以及 shared_ptr atomic_load and atomic_store。 std::shared_ptr 将确保您不会访问悬垂指针，而不变性（字符串在构造后不会更改）将保证对字符串本身的访问是线程安全的，因为所有 const 方法都由标准是线程安全的。

编辑：根据要求解释我所说的"risky business"：如果你使用std::atomic<std::string *>，那么很容易不小心引入竞争条件，例如

// Data
std::atomic<std::string *> str(new std::string("foo"));

// Thread 1
std::cout << *str.load();

// Thread 2
*str.load() = "bar"; // race condition with read access in thread 1

// Thread 2 (another attempt using immutable instances)
auto newStr = new std::string("bar");
auto oldStr = str.exchange(newStr);
delete oldStr;  /* race condition with read access in thread 1
                   because thread 1 may have performed load() before
                   the exchange became visible to it, and may not
                   be finished using the old object. */

请注意，这与 operator << 无关，即使只是在线程 1 中的字符串上调用 size() 也会导致竞争条件。

在实践中，可能会看到 "fixes" 喜欢在不可变字符串更新中的 delete 之前添加一个 sleep，以便线程 1 有足够的时间完成其业务旧指针。尽管这在特定实现中大部分时间可能有效，但它没有引入真正的顺序（happens-before 关系，在 C++ 标准语中) 因此不是正确的响应响应。便携式解决方案。

对 std::atomic::load 的结果使用结构取消引用 (->) 运算符是否安全

Is it safe to use the Structure dereference(->) operator on the result of std::atomic::load

c++

atomic

c++11

stdatomic