Summary - Concurrency

Combine thread, mutex and async to write a parallel computation.

Summary - Concurrency

In this group you met five tools of C++ concurrency: std::thread for threads, std::mutex for mutual exclusion, std::lock_guard for RAII locking, std::async for background tasks and std::future for waiting on results. They all live in the <thread> and <future> headers.

Together these tools let you write programs that run in parallel and share data safely. Now you will write a small task that combines what you learned: two threads add to a shared counter protected by a lock_guard.

Exercise Summary with thread + lock_guard

Declare global int counter = 0; and std::mutex m;. Write void add(int n) whose body is std::lock_guard<std::mutex> lk(m); counter += n;. In main start std::thread t1(add, 5); and std::thread t2(add, 3);, join both, then write std::cout << counter;.

Show example solution

#include <iostream>
#include <thread>
#include <mutex>

int counter = 0;
std::mutex m;

void add(int n) {
    std::lock_guard<std::mutex> lk(m);
    counter += n;
}

int main() {
    std::thread t1(add, 5);
    std::thread t2(add, 3);
    t1.join();
    t2.join();
    std::cout << counter;
    return 0;
}

Test yourself

Which tool is the RAII wrapper for a mutex?
- std::thread
- std::async
- std::future
- std::lock_guard
Show answer

std::lock_guard — std::lock_guard is the RAII wrapper for a mutex.
Match each tool to its purpose

std::thread

Thread
std::mutex

Mutual exclusion
std::lock_guard

RAII lock
std::future

Result wait

Complete the lock_guard line

void add(int n) {
    std::____<std::mutex> lk(m);
    counter += n;
}

Show answer

void add(int n) {
    std::lock_guard<std::mutex> lk(m);
    counter += n;
}

Next lesson: std::atomic

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies