Concurrency in C++

Introduction

The term "concurrency" describes a program's capacity to carry out several tasks at once. Concurrency in C++ is supported via the thread class in the standard library. A program's basic unit of execution, known as a thread, can operate concurrently with other threads. We will go into great detail on concurrency in C++ in this article.

Creating Threads

In order to create a thread in C++, you must first define the function that will be used by the thread, and then you must create the thread object. The executed function's signature must be void. Here is an illustration of how to make a thread that runs the function foo():

Code:

#include <iostream>
#include <thread>
void foo() {
    std::cout << "Hello from thread " << std::this_thread::get_id() << std::endl;
}
int main() {
    std::thread t(foo);
    std::cout << "Hello from main thread " << std::this_thread::get_id() << std::endl;
    t.join();
    return 0;
}

In this illustration, a separate thread created with the std::thread function Object() { [native code] } runs the function foo(). While the new thread executes the function foo, the main thread keeps going (). Before ending the program, wait for the thread to finish using the join() technique.

Synchronization

To prevent concurrent access to common resources, concurrent programs frequently need to synchronize the execution of threads. The synchronization support mechanisms provided by C++ include mutexes, condition variables, and atomic operations.

Mutexes

A mutex, which stands for "mutual exclusion," is a primitive for synchronization that is used to prevent concurrent access to shared resources by different threads. Lock() and Unlock are the two techniques that a mutex offers (). Other threads are unable to access the protected resource until the mutex is released with unlock after a thread runs lock() to take ownership of the mutex ().

Here is an illustration of how to use a mutex to prevent multiple threads from accessing a shared variable at once:

Code:

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int shared = 0;
void increment() {
    mtx.lock();
    shared++;
    mtx.unlock();
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Shared value is " << shared << std::endl;
    return 0;
}

In this illustration, a mutex is used by two threads to increase the shared variable so that only one thread can access it at once. The shared variable is consequently increased twice, with a final value of 2.

Condition Variables

Another synchronization tool used to manage thread execution is condition variables. Two options are provided by a condition variable: wait() and notify one(). A thread that uses the wait() function on a condition variable block until another thread uses the notify one() function on the same condition variable.

Here is an illustration of how to create a basic producer-consumer queue using condition variables:

Code:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
std::mutex mtx;
std::condition_variable cv;
std::queue<int> q;
void producer() {
    for (int i = 0; i < 10; i++) {
        std::unique_lock<std::mutex> lock(mtx);
        q.push(i);
        cv.notify_one();
    }
}
void consumer() {
    for (int i = 0; i < 10; i++) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !

In this illustration, the consumer thread waits for values to become available before consuming them after the producer thread pushes items onto a queue. When values are ready for consumption, the consumer thread is informed via the condition variable cv.

Atomic Operations

Another method for synchronizing access to shared resources is through atomic operations. An atomic action is one that is carried out as a single, cohesive process without the involvement of any other threads. Integers, booleans, and pointers are just a few of the fundamental kinds that can be operated on atomically in C++.

Here is an illustration of how to increase a shared variable using an atomic integer:

Code:

#include <iostream>	
#include <thread>
#include <atomic>
std::atomic<int> shared(0);
void increment() {
    shared++;
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Shared value is " << shared << std::endl;
    return 0;
}

The shared variable in this instance is an atomic integer, which allows several threads to securely increment it without the use of a mutex.

Conclusion

In conclusion, C++'s concurrency feature is a strong one that lets programs run several tasks at once. The concurrency support methods offered by C++ include threads, mutexes, conditional variables, and atomic operations. For creating concurrent programs in C++ that are effective and responsive, it is crucial to comprehend these ideas.

Next TopicC++ GUI

← prev next →