C++ shared_ptr how to ensure thread safety?

Question

all: According to this page c++ implementations typically uses atomic ref count to ensure thread safety, but this seems buggy in some cases.

```

void func2(shared_ptr<int>* x) {
  shared_ptr<int> a(*x);
  *a += 1;
}

thread func1() {
 shared_ptr<int> a1(new int(10));
 thread t (func2, &a1);
 return t;
}

```

As the above code shows, if the copy construction in func2 happens after the internal reference count of a1 decreases, the pointer will get deleted twice, right?

The buggy thing here is *your* code ... dangling raw pointer. — deviantfan, Jun 19 '16 at 14:45

score 4 · Accepted Answer · answered Jun 19 '16 at 14:50

An atomic reference count assures that only the reference counting is thread safe. It doesn't turn the referenced class into a thread safe class. It doesn't prevent you from writing thread-unsafe code, like passing a pointer to a std::shared_ptr to a new thread, but destroying it before the new thread has an opportunity to acquire its own copy of it.

You are still responsible for writing thread-safe logic. But you can rely on reference counting being thread-safe.

C++ shared_ptr how to ensure thread safety?

1 Answers1