About thread-safety of weak_ptr

by

I know I’m late, but this comes up when searching for “weak_ptr thread”, and Casey’s answer just isn’t the whole truth. Both shared_ptr and weak_ptr can be used from threads without further synchronization.

For shared_ptr, there’s a lot of documentation (e.g. on cppreference.com or on stackoverflow). You can safely access shared_ptr‘s that point to the same object from different threads. You just can’t bang on the same pointer from two threads. In other words:

// Using p and p_copy from two threads is fine.
// Using p from two threads or p and p_ref from two threads is illegal.
std::shared_ptr<A> p = std::make_shared<A>();
std::shared_ptr<A> &p_ref = p;
std::shared_ptr<A> p_copy = p;

To solve that problem in your code, pass g_s as parameter (by value)* to f1().

For weak pointers, the safety guarantee is hidden in the documentation for weak_ptr::lock:

Effectively returns expired() ? shared_ptr<T>() : shared_ptr<T>(*this), executed atomically.

You can use weak_ptr::lock() to get a shared_ptr from other threads without further synchronization. This is also confirmed here for Boost and in this SO answer by Chris Jester-Young.

Again, you have to make sure not to modify the same weak_ptr from one thread while accessing it from another, so pass g_w into f3() by value as well.

More Related Contents:

  1. Start thread with member function
  2. C++0x has no semaphores? How to synchronize threads?
  3. How do I terminate a thread in C++11?
  4. What happens to a detached thread when main() exits?
  5. Thread pooling in C++11
  6. Why is the destructor of a future returned from `std::async` blocking?
  7. What does the thread_local mean in C++11?
  8. How to check if a std::thread is still running?
  9. Does MinGW-w64 support std::thread out of the box when using the Win32 threading model?
  10. What exactly is std::atomic?
  11. How to implement multithread safe singleton in C++11 without using
  12. Difference between pointer and reference as thread parameter
  13. How would you implement your own reader/writer lock in C++11?
  14. Mixing C++11 atomics and OpenMP
  15. std::unique_lock or std::lock_guard?
  16. Does the C++ volatile keyword introduce a memory fence?
  17. How to set the stacksize with C++11 std::thread
  18. How can I use something like std::vector?
  19. Delayed start of a thread in C++ 11
  20. What is std::promise?
  21. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  22. C++11 STL containers and thread safety
  23. Passing arguments to std::async by reference fails
  24. Understanding std::atomic::compare_exchange_weak() in C++11
  25. Double-Checked Lock Singleton in C++11
  26. thread safety of MPI send using threads created with std::async
  27. C++11 Implementation of Spinlock using header “
  28. std::thread calling method of class [duplicate]
  29. Write concurrently vector
  30. Why does this simple std::thread example not work?

Leave a Comment