Multithreading in C++
Multithreading is a feature that allows concurrent execution of two or more parts of a program for maximum utilization of the CPU. Each part of such a program is called a thread. So, threads are lightweight processes within a process.
Multithreading support was introduced in C++11. Prior to C++11, we had to use POSIX threads or <pthreads> library. While this library did the job the lack of any standard language-provided feature set caused serious portability issues. C++ 11 did away with all that and gave us std::thread. The thread classes and related functions are defined in the <thread> header file.
std::thread thread_object (callable);
std::thread is the thread class that represents a single thread in C++. To start a thread we simply need to create a new thread object and pass the executing code to be called (i.e, a callable object) into the constructor of the object. Once the object is created a new thread is launched which will execute the code specified in callable. A callable can be either of the three
- A Function Pointer
- A Function Object
- A Lambda Expression
After defining the callable, we pass it to the constructor.
Launching Thread Using Function Pointer
A function pointer can be a callable object to pass to the std::thread constructor for initializing a thread. The following code snippet demonstrates how it is done.
Launching Thread Using Lambda Expression
std::thread object can also be launched using a lambda expression as a callable. The following code snippet demonstrates how this is done:
Launching Thread Using Function Objects
Function Objects or Functions can also be used for launching a thread in C++. The following code snippet demonstrates how it is done:
Note: We always pass parameters of the callable separately as arguments to the thread constructor.
Waiting for threads to finish
Once a thread has started we may need to wait for the thread to finish before we can take some action. For instance, if we allocate the task of initializing the GUI of an application to a thread, we need to wait for the thread to finish to ensure that the GUI has loaded properly.
To wait for a thread, use the std::thread::join() function. This function makes the current thread wait until the thread identified by *this has finished executing.
For instance, to block the main thread until thread t1 has finished we would do:
A Complete C++ Program For Multithreading
A C++ program is given below. It launches three threads from the main function. Each thread is called using one of the callable objects specified above.
Output (Machine Dependent)
Threads 1 and 2 and 3 operating independently Thread using function pointer as callable Thread using function pointer as callable Thread using function pointer as callable Thread using function object as callable Thread using function object as callable Thread using function object as callable Thread using lambda expression as callable Thread using lambda expression as callable Thread using lambda expression as callable
Note: To compile programs with std::thread support use g++ -std=c++11 -pthread.