std::shared_ptr thread safety explained

by

As others have pointed out, you’ve got it figured out correctly regarding your original 3 questions.

But the ending part of your edit

Calling reset() in thread IV will delete previous instance of A class created in first thread and replace it with new instance? Moreover after calling reset() in IV thread other threads will see only newly created object?

is incorrect. Only d will point to the new A(10), and a, b, and c will continue to point to the original A(1). This can be seen clearly in the following short example.

#include <memory>
#include <iostream>
using namespace std;

struct A
{
  int a;
  A(int a) : a(a) {}
};

int main(int argc, char **argv)
{
  shared_ptr<A> a(new A(1));
  shared_ptr<A> b(a), c(a), d(a);

  cout << "a: " << a->a << "\tb: " << b->a
     << "\tc: " << c->a << "\td: " << d->a << endl;

  d.reset(new A(10));

  cout << "a: " << a->a << "\tb: " << b->a
     << "\tc: " << c->a << "\td: " << d->a << endl;
                                                                                                                 
  return 0;                                                                                                          
}

(Clearly, I didn’t bother with any threading: that doesn’t factor into the shared_ptr::reset() behavior.)

The output of this code is

a: 1 b: 1 c: 1 d: 1

a: 1 b: 1 c: 1 d: 10

More Related Contents:

  1. How do I call ::std::make_shared on a class with only protected or private constructors?
  2. shared_ptr to an array : should it be used?
  3. Difference in make_shared and normal shared_ptr in C++
  4. Differences between unique_ptr and shared_ptr [duplicate]
  5. Why isn’t there a std::shared_ptr specialisation?
  6. Why do std::shared_ptr work
  7. Should we pass a shared_ptr by reference or by value?
  8. Passing shared pointers as arguments
  9. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  10. Passing shared_ptr as shared_ptr
  11. Where is shared_ptr?
  12. Should I use shared_ptr or unique_ptr
  13. What is the difference between an empty and a null std::shared_ptr in C++?
  14. How do shared pointers work?
  15. Why would I std::move an std::shared_ptr?
  16. shared_ptr and weak_ptr differences
  17. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  18. weak_ptr, make_shared and memory deallocation
  19. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  20. Optimization code for a debug function (c++11 with templates) [closed]
  21. C++ press enter to continue
  22. Thread pooling in C++11
  23. Is there any use for unique_ptr with array?
  24. Why does ‘std::vector b{2};’ create a 1-element vector, and not a 2-element one?
  25. How does the custom deleter of std::unique_ptr work?
  26. Operator overload which permits capturing with rvalue but not assigning to
  27. Why is auto_ptr being deprecated?
  28. shared_ptr is to weak_ptr as unique_ptr is to… what?
  29. Why was pair range access removed from C++11?
  30. Why can’t std::function bind to C-style variadic functions?

Leave a Comment