boost::shared_ptr is it safe to use it in multiple threads?
boost, c++, multithreading, shared-ptr
Solution
The boost docs state:
Different shared_ptr instances can be "written to" (accessed using mutable operations such as operator= or reset) simultaneosly by multiple threads (even when these instances are copies, and share the same reference count underneath.)
(emphasis mine)
So the crux here is whether you copy the `boost::shared_ptr`s between threads or not. If you create copies (the "safe" way to use `shared_ptr`s) you don't have any worries about thread-safety. If however you pass the `shared_ptr` by reference or pointer, and hence are using the actual same `shared_ptr` in different threads, you would have to worry about thread-safety, as described in the docs.
Problem
I was trying to find the answer for some time but I failed. Lets assume that we have a `shared_ptr` created from one thread. Then we pass this `shared_ptr` to another 2 threads (using some queue for example). So from this moment there are 2 copies of the original `shared_ptr`, pointing to the same raw pointer. Both owner threads will take their copies of this `shared_ptr` from the queue. Then they will pass it to another thread or will destroy it. Question is - is it safe? Will the raw pointer destroyed correctly (there will be no race to reference counter?)