Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?

by

There are several differences between Boost.Thread and the C++11 standard thread library:

  • Boost supports thread cancellation, C++11 threads do not
  • C++11 supports std::async, but Boost does not
  • Boost has a boost::shared_mutex for multiple-reader/single-writer locking. The analogous std::shared_timed_mutex is available only since C++14 (N3891), while std::shared_mutex is available only since C++17 (N4508).
  • C++11 timeouts are different to Boost timeouts (though this should soon change now Boost.Chrono has been accepted).
  • Some of the names are different (e.g. boost::unique_future vs std::future)
  • The argument-passing semantics of std::thread are different to boost::thread — Boost uses boost::bind, which requires copyable arguments. std::thread allows move-only types such as std::unique_ptr to be passed as arguments. Due to the use of boost::bind, the semantics of placeholders such as _1 in nested bind expressions can be different too.
  • If you don’t explicitly call join() or detach() then the boost::thread destructor and assignment operator will call detach() on the thread object being destroyed/assigned to. With a C++11 std::thread object, this will result in a call to std::terminate() and abort the application.

To clarify the point about move-only parameters, the following is valid C++11, and transfers the ownership of the int from the temporary std::unique_ptr to the parameter of f1 when the new thread is started. However, if you use boost::thread then it won’t work, as it uses boost::bind internally, and std::unique_ptr cannot be copied. There is also a bug in the C++11 thread library provided with GCC that prevents this working, as it uses std::bind in the implementation there too.

void f1(std::unique_ptr<int>);
std::thread t1(f1,std::unique_ptr<int>(new int(42)));

If you are using Boost then you can probably switch to C++11 threads relatively painlessly if your compiler supports it (e.g. recent versions of GCC on linux have a mostly-complete implementation of the C++11 thread library available in -std=c++0x mode).

If your compiler doesn’t support C++11 threads then you may be able to get a third-party implementation such as Just::Thread, but this is still a dependency.

More Related Contents:

  1. Example for boost shared_mutex (multiple reads/one write)?
  2. How to give priority to privileged thread in mutex locking?
  3. How can I use something like std::vector?
  4. C++11 equivalent to boost shared_mutex
  5. How do I terminate a thread in C++11?
  6. Concurrency: Atomic and volatile in C++11 memory model
  7. Passing object by reference to std::thread in C++11
  8. Why don’t compilers merge redundant std::atomic writes?
  9. How do I combine hash values in C++0x?
  10. std::thread pass by reference calls copy constructor
  11. when g++ static link pthread, cause Segmentation fault, why?
  12. Should we pass a shared_ptr by reference or by value?
  13. How to use std::async on a member function?
  14. unordered_map thread safety
  15. C++0x thread interruption
  16. Cancelling boost asio deadline timer safely
  17. What causes runtime error message: std::system_error – operation not permitted, including mult-threading? [duplicate]
  18. std::thread is not a member of namespace std using Eclipse Kepler MinGW
  19. Hash an arbitrary precision value (boost::multiprecision::cpp_int)
  20. C++ terminate called without an active exception
  21. What is different between join() and detach() for multi threading in C++?
  22. std::thread error (thread not member of std)
  23. Does std::mutex create a fence?
  24. When must you pass io_context to boost::asio::spawn? (C++)
  25. std::tuple get() member function
  26. BOOST libraries in multithreading-aware mode
  27. Assert that code does NOT compile
  28. Using condition variable in a producer-consumer situation
  29. GCC std::thread not found in namespace std
  30. Why does this simple std::thread example not work?

Leave a Comment