Upgrade concurrency module to real threads and thread-aware build scripts

Author: lucasbellesi

languages/cpp/04-expert/concurrency-basics/README.md

@@ -1,47 +1,49 @@
 # Concurrency Basics
 
-This module introduces concurrency concepts: interleaving, shared-state hazards, and synchronization intent.
+This module introduces real multithreaded programming with `std::thread`.
 
 ## Quick Run
 
 ```bash
-g++ -std=c++17 -Wall -Wextra -pedantic example/main.cpp -o concurrency_basics_example
+g++ -std=c++17 -Wall -Wextra -pedantic -pthread example/main.cpp -o concurrency_basics_example
 ./concurrency_basics_example
 ```
 
+On Linux, `-pthread` is required for thread support.
+
 ## Topics Covered
 
-- Task interleaving concept.
-- Race condition intuition.
-- Critical section idea.
-- Why mutexes/atomics are needed in real multithreaded code.
+- Creating and joining threads with `std::thread`.
+- Protecting shared state with `std::mutex` and `std::lock_guard`.
+- Coordinating producer/consumer workflows with `std::condition_variable`.
+- Preventing race conditions in shared data updates.
 
 ## Common Pitfalls
 
-- Assuming shared updates are always safe.
-- Treating read-modify-write as atomic when it is not.
-- Ignoring ordering effects between operations.
+- Reading/writing shared state without synchronization.
+- Forgetting to join threads before program exit.
+- Waiting on condition variables without a predicate.
 
 ## Exercise Focus
 
-- `exercises/01.cpp`: simulate parallel chunk sum with interleaved steps.
-- `exercises/02.cpp`: producer-consumer simulation with queue operations.
+- `exercises/01.cpp`: parallel chunk sum with worker threads.
+- `exercises/02.cpp`: producer-consumer queue with mutex and condition variable.
 
 ### Exercise Specs
 
 1. `exercises/01.cpp`
-- Input: list of integers and chunk size.
-- Output: partial sums and final sum.
-- Edge cases: chunk size larger than list; empty list.
+- Input: list of integers and number of worker threads.
+- Output: per-thread partial sums and final total.
+- Edge cases: thread count larger than list size; non-positive thread count.
 
 2. `exercises/02.cpp`
-- Input: sequence of produce/consume commands.
-- Output: queue state transitions.
-- Edge cases: consume on empty queue; multiple produce before consume.
+- Input: number of items to produce.
+- Output: produced/consumed item logs and completion summary.
+- Edge cases: zero items; consumer waiting while queue is empty.
 
 ## Checkpoint
 
-- [ ] I can explain race conditions with examples.
-- [ ] I can identify critical sections in shared-state workflows.
-- [ ] I understand why synchronization primitives are required in real threads.
+- [ ] I can create and join worker threads safely.
+- [ ] I can protect critical sections with a mutex.
+- [ ] I can coordinate producers and consumers correctly.
 - [ ] I completed both exercises.

languages/cpp/04-expert/concurrency-basics/example/main.cpp

@@ -1,27 +1,36 @@
 #include <iostream>
+#include <mutex>
+#include <thread>
 #include <vector>
 
 int main() {
-    int sharedCounter = 0;
+    const int threadCount = 4;
+    const int incrementsPerThread = 50000;
 
-    std::cout << "Simulated interleaving of two tasks:\n";
+    int counter = 0;
+    std::mutex counterMutex;
 
-    std::cout << "Task A reads " << sharedCounter << '\n';
-    int taskATemp = sharedCounter;
+    auto worker = [&counter, &counterMutex, incrementsPerThread]() {
+        for (int i = 0; i < incrementsPerThread; ++i) {
+            std::lock_guard<std::mutex> lock(counterMutex);
+            ++counter;
+        }
+    };
 
-    std::cout << "Task B reads " << sharedCounter << '\n';
-    int taskBTemp = sharedCounter;
+    std::vector<std::thread> threads;
+    threads.reserve(static_cast<std::size_t>(threadCount));
 
-    ++taskATemp;
-    ++taskBTemp;
+    for (int i = 0; i < threadCount; ++i) {
+        threads.emplace_back(worker);
+    }
 
-    sharedCounter = taskATemp;
-    std::cout << "Task A writes " << sharedCounter << '\n';
+    for (std::thread& thread : threads) {
+        thread.join();
+    }
 
-    sharedCounter = taskBTemp;
-    std::cout << "Task B writes " << sharedCounter << '\n';
-
-    std::cout << "Final counter: " << sharedCounter << " (expected 2 in synchronized execution)\n";
+    const int expected = threadCount * incrementsPerThread;
+    std::cout << "Expected: " << expected << '\n';
+    std::cout << "Actual: " << counter << '\n';
 
     return 0;
 }

languages/cpp/04-expert/concurrency-basics/exercises/01.cpp

@@ -1,45 +1,68 @@
 #include <iostream>
+#include <thread>
 #include <vector>
 
 int main() {
     int n = 0;
-    std::cout << "How many values? ";
+    std::cout << "How many integers? ";
     std::cin >> n;
 
     if (n <= 0) {
-        std::cout << "No data to sum.\n";
+        std::cout << "Please enter a positive count.\n";
         return 0;
     }
 
     std::vector<int> values;
     values.reserve(static_cast<std::size_t>(n));
-
     for (int i = 0; i < n; ++i) {
         int value = 0;
         std::cin >> value;
         values.push_back(value);
     }
 
-    int chunkSize = 0;
-    std::cout << "Chunk size: ";
-    std::cin >> chunkSize;
+    int workerCount = 0;
+    std::cout << "How many worker threads? ";
+    std::cin >> workerCount;
 
-    if (chunkSize <= 0) {
-        std::cout << "Chunk size must be positive.\n";
+    if (workerCount <= 0) {
+        std::cout << "Worker count must be positive.\n";
         return 0;
     }
 
-    int total = 0;
-    for (int start = 0; start < n; start += chunkSize) {
-        int partial = 0;
-        const int end = (start + chunkSize < n) ? (start + chunkSize) : n;
-        for (int i = start; i < end; ++i) {
-            partial += values[static_cast<std::size_t>(i)];
-        }
-        std::cout << "Partial sum [" << start << ", " << (end - 1) << "]: " << partial << '\n';
-        total += partial;
+    if (workerCount > n) {
+        workerCount = n;
+    }
+
+    std::vector<long long> partialSums(static_cast<std::size_t>(workerCount), 0);
+    std::vector<std::thread> workers;
+    workers.reserve(static_cast<std::size_t>(workerCount));
+
+    const int chunkSize = (n + workerCount - 1) / workerCount;
+
+    for (int workerIndex = 0; workerIndex < workerCount; ++workerIndex) {
+        workers.emplace_back([&values, &partialSums, workerIndex, chunkSize, n]() {
+            const int start = workerIndex * chunkSize;
+            const int end = (start + chunkSize < n) ? (start + chunkSize) : n;
+
+            long long localSum = 0;
+            for (int i = start; i < end; ++i) {
+                localSum += values[static_cast<std::size_t>(i)];
+            }
+
+            partialSums[static_cast<std::size_t>(workerIndex)] = localSum;
+        });
+    }
+
+    for (std::thread& worker : workers) {
+        worker.join();
+    }
+
+    long long total = 0;
+    for (std::size_t i = 0; i < partialSums.size(); ++i) {
+        std::cout << "Thread " << i << " partial sum: " << partialSums[i] << '\n';
+        total += partialSums[i];
     }
 
-    std::cout << "Total sum: " << total << '\n';
+    std::cout << "Final total: " << total << '\n';
     return 0;
 }

languages/cpp/04-expert/concurrency-basics/exercises/02.cpp

@@ -1,37 +1,61 @@
+#include <condition_variable>
 #include <iostream>
+#include <mutex>
 #include <queue>
-#include <string>
+#include <thread>
 
 int main() {
-    std::queue<int> q;
+    int itemsToProduce = 0;
+    std::cout << "How many items should be produced? ";
+    std::cin >> itemsToProduce;
 
-    std::cout << "Enter commands: produce <x>, consume, stop\n";
-    while (true) {
-        std::string command;
-        std::cin >> command;
+    if (itemsToProduce < 0) {
+        std::cout << "Please enter a non-negative value.\n";
+        return 0;
+    }
+
+    std::queue<int> queue;
+    std::mutex queueMutex;
+    std::condition_variable queueCv;
+    bool productionFinished = false;
+    int consumedCount = 0;
+
+    std::thread producer([&]() {
+        for (int i = 1; i <= itemsToProduce; ++i) {
+            {
+                std::lock_guard<std::mutex> lock(queueMutex);
+                queue.push(i);
+                std::cout << "Produced: " << i << '\n';
+            }
+            queueCv.notify_one();
+        }
 
-        if (!std::cin) {
-            break;
+        {
+            std::lock_guard<std::mutex> lock(queueMutex);
+            productionFinished = true;
         }
+        queueCv.notify_one();
+    });
 
-        if (command == "produce") {
-            int value = 0;
-            std::cin >> value;
-            q.push(value);
-            std::cout << "Produced " << value << ", size=" << q.size() << '\n';
-        } else if (command == "consume") {
-            if (q.empty()) {
-                std::cout << "Queue is empty.\n";
-            } else {
-                std::cout << "Consumed " << q.front() << '\n';
-                q.pop();
+    std::thread consumer([&]() {
+        while (true) {
+            std::unique_lock<std::mutex> lock(queueMutex);
+            queueCv.wait(lock, [&]() { return productionFinished || !queue.empty(); });
+
+            if (queue.empty() && productionFinished) {
+                break;
             }
-        } else if (command == "stop") {
-            break;
-        } else {
-            std::cout << "Unknown command.\n";
+
+            const int value = queue.front();
+            queue.pop();
+            ++consumedCount;
+            std::cout << "Consumed: " << value << '\n';
         }
-    }
+    });
+
+    producer.join();
+    consumer.join();
 
+    std::cout << "Finished. Total consumed: " << consumedCount << '\n';
     return 0;
 }

scripts/build-all.ps1

@@ -12,11 +12,16 @@ if ($cppFiles.Count -eq 0) {
 $buildDir = Join-Path $root "build"
 New-Item -ItemType Directory -Force -Path $buildDir | Out-Null
 
+$extraFlags = @()
+if ($IsLinux -or $IsMacOS) {
+    $extraFlags += "-pthread"
+}
+
 $index = 0
 foreach ($file in $cppFiles) {
     $output = Join-Path $buildDir ("check_" + $index)
     Write-Host "Compiling: $($file.FullName)"
-    g++ -std=c++17 -Wall -Wextra -pedantic $file.FullName -o $output
+    g++ -std=c++17 -Wall -Wextra -pedantic @extraFlags $file.FullName -o $output
     $index++
 }
 

scripts/build-all.sh

@@ -13,11 +13,18 @@ fi
 
 mkdir -p build
 
+extra_flags=()
+case "$(uname -s)" in
+  Linux*|Darwin*)
+    extra_flags+=(-pthread)
+    ;;
+esac
+
 index=0
 for file in "${files[@]}"; do
   output="build/check_${index}"
   echo "Compiling: $file"
-  g++ -std=c++17 -Wall -Wextra -pedantic "$file" -o "$output"
+  g++ -std=c++17 -Wall -Wextra -pedantic "${extra_flags[@]}" "$file" -o "$output"
   index=$((index + 1))
 done