boost thread vs std thread vs posix thread

Introduction

Posix thread is oldest in time order and was heavily used across multiple applications. However, thread programming is always considered as different. It may be due to synchronisation difficulties, reentrant code, deadlock risk and so on. Even debugging is quite involved. Static code analyser too faces difficulties in capturing thread specific issues.

In order to better manage threads, boost community came up with C++ based thread APIs. This library uses posix thread underline. However, it provides the great option to software designer to design and implement threads in object oriented fashion.

Boost thread replicates most pthread functionalities. However for a few functionalities which are not supported in boost can also be availed using pthread native handle.

Things pthreads has that boost::thread lacks:

When you use boost::thread you can grab the underlying pthread_t (or pthread_mutex_t, etc.) by calling the native_handle() member function, and use it to regain back functionality not supplied directly by boost::thread.

• • Set scheduling parameters (pthread_attr_setschedparam)

  • Stack query, manipulation (pthread_attr_getstacksize)

  • Mutex/priority query, manipulation (pthread_mutex_getprioceiling)

Things boost::thread has that pthreads lacks:

The following things can be done in pthreads (after all boost::thread is implemented on pthreads). But there isn't clear and direct API in pthreads to do these things.

• • Different types for a thread handle, and a thread id

  • A thread id that can represent "not any thread"

  • The ability to launch a thread on an arbitrary functor with arbitrary arguments

  • The ability to "call once" an arbitrary functor with arbitrary arguments

  • The ability for a condition variable to wait on an arbitrary lockable type

  • The ability to lock multiple mutexes at once without deadlock

  • A portable way to store thread id's in associative containers

  • RAII support for unlocking mutexes

• 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, which is not present in C++11

  • 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.

Reference

http://stackoverflow.com/questions/7241993/is-it-smart-to-replace-boostthread-and-boostmutex-with-c11-equivalents

http://stackoverflow.com/questions/6928651/what-are-the-prominant-differnces-in-the-boost-thread-library-or-the-pthreads