Linux is a new platform to me. I\'ve coded on Windows in c++ for a number of years and have become comfortable with multithreading on that platform.
Along comes C++
std::thread
is boost::thread accepted into C++11 with some extras. My understanding is that if boost::thread
gets replaced in code with std::thread
it should still compile and work.
boost::thread
is based on pthreads
design, providing thin C++ wrappers over thread, mutex and condition variables. Thread cancellation though was left outside the scope of C++11, since there was no agreement how it should work in C++.
So, by learning pthreads
you also learn std::thread
concepts. std::thread
adds mostly syntax sugar and convenience functions on top of pthreads
C API.
With regards to WaitForMultipleObjects()
, neither pthreads
nor std::thread
provide anything similar to its bWaitAll=FALSE
mode, however, it's routinely simulated using pipes and select()
on UNIX, or more modern eventfd()
and epoll()
on Linux. bWaitAll=TRUE
mode can be simulated by waiting on all tasks in turn, since it doesn't proceed until all objects are ready anyway.
Based on this, you must call pthread_join
for each single thread you have created. Or to use mutexes, if there is a need to synchronize your threads.
Regarding WaitForMultipleObjects
, this is generally called a Barrier Sync. Boost has an implementation called barrier. It uses conditional variables to implement it, in posix its a pthread_cond_t
Here is an answer I left recently explaining barrier sync.
No, neither pthreads nor C++11 has direct equivalent of WaitForMultipleObjects
(i.e. wait for any waitable "handle" type.) pthread_join
can only be used to join threads, and only a single, specific thread.
The closest equivalent on posix platforms is to wait for multiple file descriptors using system calls such as select(), poll() or the linux-specific epoll(), but they require you to have a file descriptor to wait on, which is fine for I/O events but requires extra work from you to use them wait for mutexes, condition variables or other synchronisation objects. There are more general event libraries built on top of those system calls, e.g. libevent and libev and Boost ASIO, which support waiting for timers as well as I/O, but still not thread completion, mutex locks etc. with a single function like WaitForMultipleObjects
The alternatives you do have for pthreads and C++11 threads are to wait on different synchronisation types separately. You can wait for timers, wait for threads to complete, wait for mutexes, wait on condition variables, wait for asynchronous results to be ready (std::async
in C++11, no direct equivalent in pthreads) ... but there's no call that will allow you to wait a heterogeneous set of those types all at once.
I could give you a really fancy answer but alas, this is where I learned them and it is a good introduction:
http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html
You use pthread_mutex_t
for syncronization and pthread_join
probably handles the wait for multiple tasks problem. It works exactly as you would expect.