Are operations with the internal pointer of shared_ptr atomic?

Question

Is it safe to copy and reset shared_ptr at the same time?

Namely consider the following code

// Main thread (before creating any other threads)
shared_ptr<A> a(new A(1));

// Thread 1
shared_ptr<A> a_copy = a;

// Thread 2
a.reset(new(A(2));

where thread 1 and 2 run in parallel. Can I be sure, that a_copy will store pointer either to the older A(1) or to the newer A(2) shared object?

Answer 1

From cppreference:

All member functions (including copy constructor and copy assignment) can be called by multiple threads on different instances of shared_ptr without additional synchronization even if these instances are copies and share ownership of the same object.

So, the answer is no — these operations are not thread-safe because both the copy and the reset are applied to the same instance, a. The result is a data race, which leads to undefined behavior.

Answer 2

No they are not, see @Potatoswatter answer.

But if you do need to atomically operate a shared_ptr, you can use these dedicated functions. (Although AFAIK they are only implemented on recent versions of GCC/Clang).

So your example would be:

// Main thread (before creating any other threads)
shared_ptr<A> a(new A(1));

// Thread 1
shared_ptr<A> a_copy = atomic_load(&a);

// Thread 2
atomic_store(&a, make_shared<A>(2) );