Shared Pointers in Multithreaded Environments

The shared_ptr class itself is thread-safe, but this doesn't automatically make your application thread-safe.

The reference count on the shared_ptr is incremented and decremented atomically. This means that multiple threads can simultaneously create copies of a shared_ptr, and the shared_ptr will correctly keep track of how many references exist.

However, this doesn't protect the object that the shared_ptr points to. If multiple threads access the pointed-to object, you still need to synchronize those accesses to avoid data races.

Consider this example:

1#include <iostream>
2#include <memory>
3#include <thread>
4
5class Counter {
6public:
7  void increment() {
8    ++count;
9  }
10
11  int getCount() {
12    return count;
13  }
14
15private:
16  int count = 0;
17};
18
19int main() {
20  auto counter = std::make_shared<Counter>();
21
22  std::thread t1([counter]() {
23    for (int i = 0; i < 1000000; ++i) {
24      counter->increment();
25    }
26  });
27
28  std::thread t2([counter]() {
29    for (int i = 0; i < 1000000; ++i) {
30      counter->increment();
31    }
32  });
33
34  t1.join();
35  t2.join();
36
37  std::cout << "Final count is " << counter->getCount() << '\n';
38}

1Final count is 1054186

In this example, two threads are sharing a Counter object through a shared_ptr. However, the output of this program is undefined. Running the program a second time, our output is likely different:

1Final count is 1060707

Even though the shared_ptr is safely shared between the threads, the Counter object is not being accessed in a thread-safe way. The increment operation is not atomic, so the threads can interfere with each other, leading to lost increments.

To fix this, you would need to use a mutex or other synchronization primitive to protect the count variable:

1#include <iostream>
2#include <memory>
3#include <mutex>
4#include <thread>
5
6class Counter {
7 public:
8  void increment() {
9    std::lock_guard<std::mutex> lock(mutex);  
10    ++count;
11  }
12
13  int getCount() {
14    std::lock_guard<std::mutex> lock(mutex);  
15    return count;
16  }
17
18 private:
19  int count = 0;
20  std::mutex mutex;
21};
22
main function (unchanged)|Show
23int main() {/*...*/}

1Final count is 2000000

Now, the access to count is protected by a mutex, so the program is thread-safe.

In summary, shared_ptr makes it safe to share ownership of an object between threads, but it doesn't automatically make the object itself thread-safe. That still requires proper synchronization in the object's member functions.