Data Races and Thread Synchronization with std::mutex0%

RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Data Races and Thread Synchronization with std::mutex

Advanced13 min read•Updated: 2026-10-22

🔒 Data Races and Thread Synchronization with std::mutex

Introduction

When two or more threads access the same memory location concurrently and at least one thread modifies it without synchronization, you have a Data Race. Data races constitute Undefined Behavior: numbers get corrupted, memory pointers desynchronize, and software crashes unpredictably.

💥 The Race Condition Demonstrated

1// ❌ BROKEN: Multiple threads increment counter without locking
2int sharedCounter = 0;
3// If 10 threads increment 1,000 times each, sharedCounter will NOT be 10,000!
4// Assembly: LOAD -> INCREMENT -> STORE (Interleaved across cores)

🛡️ Protecting the Critical Section with `std::mutex`

A std::mutex (mutual exclusion) ensures that only one thread can execute a critical section at any given instant:

1#include <iostream>
2#include <thread>
3#include <vector>
4#include <mutex>
5 
6int g_sharedCounter = 0;
7std::mutex g_counterMutex;
8 
9void safeIncrement(int iterations) {
10    for (int i = 0; i < iterations; ++i) {
11        g_counterMutex.lock(); // Enter critical section
12        ++g_sharedCounter;
13        g_counterMutex.unlock(); // Exit critical section
14    }
15}
16 
17int main() {
18    std::vector<std::jthread> workers;
19 
20    // Launch 10 parallel threads, each incrementing 1,000 times:
21    for (int i = 0; i < 10; ++i) {
22        workers.emplace_back(safeIncrement, 1000);
23    }
24 
25    workers.clear(); // Joins all threads
26 
27    std::cout << "Final Expected Counter: 10000\n";
28    std::cout << "Actual Computed Counter: " << g_sharedCounter << "\n";
29 
30    return 0;
31}

Next Lesson

RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Creating and Joining Threads with std::thread and std::jthread	RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Data Races and Thread Synchronization with std::mutex

Advanced13 min read•Updated: 2026-10-22

Study Materials

🔒 Data Races and Thread Synchronization with std::mutex

Introduction

💥 The Race Condition Demonstrated

1// ❌ BROKEN: Multiple threads increment counter without locking
2int sharedCounter = 0;
3// If 10 threads increment 1,000 times each, sharedCounter will NOT be 10,000!
4// Assembly: LOAD -> INCREMENT -> STORE (Interleaved across cores)

🛡️ Protecting the Critical Section with `std::mutex`

A std::mutex (mutual exclusion) ensures that only one thread can execute a critical section at any given instant:

1#include <iostream>
2#include <thread>
3#include <vector>
4#include <mutex>
5 
6int g_sharedCounter = 0;
7std::mutex g_counterMutex;
8 
9void safeIncrement(int iterations) {
10    for (int i = 0; i < iterations; ++i) {
11        g_counterMutex.lock(); // Enter critical section
12        ++g_sharedCounter;
13        g_counterMutex.unlock(); // Exit critical section
14    }
15}
16 
17int main() {
18    std::vector<std::jthread> workers;
19 
20    // Launch 10 parallel threads, each incrementing 1,000 times:
21    for (int i = 0; i < 10; ++i) {
22        workers.emplace_back(safeIncrement, 1000);
23    }
24 
25    workers.clear(); // Joins all threads
26 
27    std::cout << "Final Expected Counter: 10000\n";
28    std::cout << "Actual Computed Counter: " << g_sharedCounter << "\n";
29 
30    return 0;
31}

Next Lesson

RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Creating and Joining Threads with std::thread and std::jthread	RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

🔒 Data Races and Thread Synchronization with std::mutex

Introduction

💥 The Race Condition Demonstrated

🛡️ Protecting the Critical Section with std::mutex

RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Related Lessons

Practice Quiz

Loading Page Content...

🔒 Data Races and Thread Synchronization with std::mutex

Introduction

💥 The Race Condition Demonstrated

🛡️ Protecting the Critical Section with std::mutex

RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock

Related Lessons

Practice Quiz

🛡️ Protecting the Critical Section with `std::mutex`

🛡️ Protecting the Critical Section with `std::mutex`