Concurrency 1: threads, mutexes and data races

Why concurrency?

Modern computers and phones have several CPU cores. A normal program uses one. Concurrency means running several tasks at overlapping times, for example resizing 1,000 photos on 8 cores, or keeping an app's screen responsive while a download runs. In C++, the basic tool is a thread: an independent sequence of instructions inside the same program, sharing the same memory.

#include <iostream>
#include <thread>

void download(int fileId) {
    std::cout << "downloading " << fileId << '\n';
}

int main() {
    std::thread t1(download, 1);
    std::thread t2(download, 2);
    t1.join();                    // wait for t1 to finish
    t2.join();
    std::cout << "all done\n";
}

Data races

int counter = 0;
void addMany() { for (int i = 0; i < 100000; ++i) ++counter; }

std::thread a(addMany), b(addMany);
a.join(); b.join();
std::cout << counter << '\n';    // often LESS than 200000, and different each run

A data race happens when two threads access the same memory at the same time, at least one of them writes, and nothing orders the accesses. In C++, a data race is undefined behaviour: wrong totals, crashes, or bugs that appear only on some machines and only sometimes. These are among the hardest bugs to find.

Protecting shared data with a mutex

#include <mutex>
#include <thread>

int counter = 0;
std::mutex counterMutex;

void addMany() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(counterMutex);   // locks here
        ++counter;
    }                                                     // unlocks here (RAII)
}
// Now counter is always 200000.

Deadlock

A deadlock happens when thread A holds mutex 1 and waits for mutex 2, while thread B holds mutex 2 and waits for mutex 1. Both wait forever. Avoid it by always locking mutexes in the same order, or by locking several at once with std::scoped_lock lock(m1, m2); (C++17), which uses a deadlock-avoidance algorithm.

Good habits

• Share as little as possible. Give each thread its own data and combine the results at the end.
• Keep locked sections short; never do slow I/O while holding a lock if you can avoid it.
• Never call unknown code (callbacks) while holding a lock.
• Use thread-safe tools from the standard library instead of inventing your own.
• Compile with -fsanitize=thread (ThreadSanitizer, GCC and Clang) while testing: it reports data races with the lines involved.

How many threads?

std::thread::hardware_concurrency() returns a hint of how many threads can truly run at once (often the number of logical cores). Creating thousands of threads is wasteful: each has its own stack and switching between them costs time. For many small jobs, real projects use a thread pool (a fixed set of worker threads taking tasks from a queue), usually from a library.