Cpp Programming Multithreading And Concurrency Intro Complete Guide

Example 1: Creating and Joining Threads

Step 1: Include Necessary Headers

#include <iostream>
#include <thread>

Step 2: Define a Function that Will Be Executed by a Thread

void threadFunction() {
    std::cout << "Hello from a thread!" << std::endl;
}

Step 3: Create and Run a Thread

int main() {
    // Create a thread named t1 that runs the function threadFunction
    std::thread t1(threadFunction);
    
    // Wait for t1 to finish executing its function
    t1.join();
    
    return 0;
}

Explanation:

• Include Headers: #include <thread> lets you use threading capabilities.
• Define Function: threadFunction() will be executed by the thread.
• Create Thread: std::thread t1(threadFunction); creates a thread t1 and starts it executing threadFunction.
• Join Thread: t1.join(); ensures that the main function waits for t1 to complete before it exits.

Example 2: Using Lambda Functions as Thread Handlers

Step 1: Include Necessary Headers

#include <iostream>
#include <thread>

Step 2: Use a Lambda Function to Define Code for the Thread

int main() {
    // Create a thread using a lambda function
    std::thread t2([]() {
        std::cout << "Hello from a thread using a lambda!" << std::endl;
    });
    
    // Wait for t2 to finish
    t2.join();
    
    return 0;
}

Explanation:

• Lambda Function: []() specifies an inline function that will be run by the thread.
• Thread Execution: The lambda function prints a message when executed by t2.

Example 3: Passing Arguments to Threads

Step 1: Include Necessary Headers

#include <iostream>
#include <thread>

Step 2: Define a Function That Takes Arguments

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

Step 3: Pass Arguments When Creating the Thread

int main() {
    std::string myMessage = "Hello from a thread with arguments!";
    
    // Create a thread passing myMessage by value
    std::thread t3(printMessage, myMessage);
    
    // Wait for t3 to finish
    t3.join();
    
    return 0;
}

Explanation:

• Pass by Value: std::thread t3(printMessage, myMessage); passes myMessage by value to the function printMessage.

Note: To pass by reference, you can use std::ref():

std::thread t4(printMessage, std::ref(myMessage));

Example 4: Handling Multiple Threads

Step 1: Include Necessary Headers

#include <iostream>
#include <thread>

Step 2: Define a Function That Takes Arguments

void printMessageMultipleTimes(const std::string& message, int times) {
    for(int i = 0; i < times; ++i)
        std::cout << message << std::endl;
}

Step 3: Create and Manage Multiple Threads

int main() {
    std::string msg1 = "Thread 1";
    std::string msg2 = "Thread 2";
    
    // Create two threads
    std::thread t5(printMessageMultipleTimes, msg1, 3);
    std::thread t6(printMessageMultipleTimes, msg2, 5);
    
    // Wait for both threads to finish
    t5.join();
    t6.join();
    
    return 0;
}

Explanation:

• Multi-threading: Two separate threads t5 and t6 run the same function but with different parameters.
• Synchronization: t5.join() and t6.join() ensure the main thread waits for both t5 and t6 to complete.

Example 5: Detaching Threads (Running Independently)

Step 1: Include Necessary Headers

#include <iostream>
#include <thread>
#include <chrono> // For std::this_thread::sleep_for

Step 2: Define a Long-running Function

void longRunningFunction() {
    for(int i = 0; i < 5; ++i) {
        std::cout << "Still working..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1)); // Sleep for 1 second
    }
}

Step 3: Detach a Thread to Run Independently

int main() {
    std::thread t7(longRunningFunction);
    
    // Detach the thread
    t7.detach();
    
    // Main function continues running
    std::cout << "Main function continuing..." << std::endl;
    
    // Sleep main thread so detached thread has time to finish
    std::this_thread::sleep_for(std::chrono::seconds(6));
    
    return 0;
}

Explanation:

• Detachment: t7.detach() makes the thread independent of the main thread. It will continue running on its own even after main() completes.
• Sleep: Adding sleep (std::this_thread::sleep_for) in main() allows the detached thread to print all its messages before the program exits.

Example 6: Basic Mutex Usage to Avoid Data Races

Step 1: Include Necessary Headers

#include <iostream>
#include <thread>
#include <mutex> // For std::mutex

Step 2: Define a Shared Variable and a Mutex

int shared_counter = 0;
std::mutex mtx; // Mutex for protection

Step 3: Define a Function to Increment a Counter

void incrementCounter(int numIterations) {
    for(int i = 0; i < numIterations; ++i) {
        mtx.lock(); // Lock the mutex
        shared_counter++;
        mtx.unlock(); // Unlock the mutex
    }
}

Step 4: Create and Manage Threads with Mutual Exclusion

int main() {
    // Create three threads that increment the shared counter
    std::thread t8(incrementCounter, 100000);
    std::thread t9(incrementCounter, 100000);
    std::thread t10(incrementCounter, 100000);
    
    // Wait for all threads to finish
    t8.join();
    t9.join();
    t10.join();
    
    // Print the final value of the shared counter
    std::cout << "Final counter value: " << shared_counter << std::endl; 
    
    return 0;
}

Explanation:

• Mutex: std::mutex mtx; protects access to shared_counter.
• Lock/Unlock: mtx.lock() and mtx.unlock(); ensure only one thread modifies shared_counter at a time, preventing a data race.

Improved with Lock Guard:

To make the code safer and more concise, you can use std::lock_guard, which automatically locks and unlocks the mutex.

void incrementCounterWithLockGuard(int numIterations) {
    for(int i = 0; i < numIterations; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // Automatically locks and unlocks mtx
        shared_counter++;
    }
}

int main() {
    // Create three threads with lock guard
    std::thread t11(incrementCounterWithLockGuard, 100000);
    std::thread t12(incrementCounterWithLockGuard, 100000);
    std::thread t13(incrementCounterWithLockGuard, 100000);
    
    // Wait for all threads to finish
    t11.join();
    t12.join();
    t13.join();
    
    // Print the final value of the shared counter
    std::cout << "Final counter value with lock guard: " << shared_counter << std::endl; 
    
    return 0;
}

This concludes our beginner-friendly introduction to multithreading and concurrency in C++. These examples should give you a good starting point to understand how threads work and how to handle concurrency issues like data races.