learning threads on linux

Question

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++11 at a time when I need to learn c++ on the linux platform.

Linux appears to use pthreads for the most part - okay there's also boost::threads and QT have their own threads too. But with C++11 comes std::thread, a whole new (cross platform and C++ standard) way to do threads.

So I guess I'll have to learn pthreads and std::threads. Ultimately, std::thread seems more important, but there's a lot of legacy code out there, so I'll have to know both.

For thread synchronization on windows, I would use WaitForMultipleObjects to wait for a number of tasks to complete before continuing with further work.

Does a similar synchronization mechanism exist for pthreads? std::threads?

I've had a look at pthread_join , and it seems to have the facility to only wait on one thread at a time. Am I missing another pthread call maybe?

Answer 1

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.

Answer 2

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.

Answer 3

No, neither pthreads nor C++11 has direct equivalent of WaitForMultipleObjects (ie 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, eg 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.

Answer 4

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.

Answer 5

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.