Multithreading_in_C++ - std::thread, race condition

Programming with Sikander
Corporate Trainer: C, Modern C++, Python, Linux System Prog
YouTube :
https://www.youtube.com/playlist?list=PLXfErIZsDibZTMKS-istzXHTTlbS0U37O
1

Multithreading
Original C++ Standard supported only
single thread programming.
The new C++ Standard, C++11, a new
thread library is introduced.
In every C++ application there is one
default main thread i.e. main() function.
We can create additional threads by
creating objects of std::thread class.
Each of the std::thread object can be
associated with a thread.
Programming with Sikander : Modern C++: Multithreading 2

Thread Creation
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.
The callable can be
▪ Address of function / Lambda Expression
▪ Function Object (Member Function)

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

Thread creation – Global Function

If a thread object is not initialized, it can
be assigned at a later stage.

Differentiating between threads
Every running thread has an id.
Thread id can be obtained using get_id
method.
To refer to current thread: this_thread.
Every process starts a new thread
generally referred as the main thread.

Difference between function call
and Thread

Multiple threads running parallel

Argument Passing to thread

Passing Multiple arguments

Two threads running on same
function

What is the output?

Passing argument by reference

Starting a Thread with a Member
Function
◼ Starting a thread with a member function
of a class requires special attention.
◼ Thread Initialization

Data Sharing and Race Conditions
In multithreading environment data sharing
between threads is very easy.
But this easy sharing of data can cause
problems in application.
One such problem is Race Condition.

What is the output?

Race Condition
When two or more threads perform a set of
operations in parallel, that access the same
memory location.
Also, one or more thread out of them modifies
the data in that memory location, then this can
lead to an unexpected results some times.
This is called race condition.
Race conditions are usually hard to find because
they don’t occur every time.
They will occur only when relative order of
execution of operations by two or more threads
leads to an unexpected result.

Race Condition

Fixing Race Condition
• To fix race conditions in multi-threaded
environment we need mutex.
• Each thread needs to lock a mutex before
modifying or reading the shared data and after
modifying the data each thread should unlock the
mutex.
• The mutexes are in the <mutex> header file.
• The class representing a mutex is the std::mutex
class.
• There are two important methods of mutex:
1.) lock()
2.) unlock() Programming with Sikander : Modern C++: Multithreading 25

Mutex
A mutex is a lockable object that is
designed to signal when critical sections
of code need exclusive access, preventing
other threads with the same protection
from executing concurrently and access
the same memory locations.

What will happen when you forget to
unlock a mutex.

Mutex Management
◼
◼

std::lock_guard
• A C++ Standard Library class for automatic locking
and unlocking of mutexes.
• Simple ownership model: Lock acquired on
construction, released on destruction
Example:
#include <mutex>
std::mutex myMutex;
std::lock_guard<std::mutex> lock(myMutex);
// ... critical section ...
// lock automatically released upon scope exit

std::lock_guard
lock_guard wraps the mutex inside it’s object
and locks the attached mutex in its constructor.
When it’s destructor is called it releases the
mutex.
In this way, it guarantees the mutex object is
properly unlocked in case an exception is
thrown.

std::lock_guard

• Advantages:
• Straightforward usage.
• Minimal code for basic locking scenarios.
• Limitations:
• Lack of advanced features like deferred
locking.
std::lock_guard

Std::unique_lock
A unique lock is an object that manages
a mutex object with unique ownership.
On construction, the object acquires
a mutex object, for whose locking and
unlocking operations becomes responsible.
The object supports both states: locked and
unlocked.
This class guarantees an unlocked status on
destruction (even if not called explicitly).

Unique Lock

Future
Futures are a high level mechanism for
passing a value between threads, and
allow a thread to wait for a result to be
available without having to manage the
locks directly.
One use of a future is to hold the result of
a call to the new async function for
running some code asynchronously

future<int> f=async(launch::async, calculate, 5);
future<int> f=async(launch::deferred, calculate, 5);

std::promise
◼ std::promise is a C++ Standard Library class
that provides a simple mechanism for
asynchronous communication between
threads.
◼ A std::promise object represents a promise
for a value that will be made available in the
future.
◼ It is typically used in conjunction with a
std::future object, which is used to retrieve
the value at a later point in the program's
execution.

THANK YOU

Multithreading_in_C++ - std::thread, race condition

In this document

More Related Content

What's hot

Similar to Multithreading_in_C++ - std::thread, race condition

More from Mohammed Sikander

Recently uploaded

Multithreading_in_C++ - std::thread, race condition