Threading

Warning: Threading was not actually covered that extensively in the lectures. I've included some additional information from online sources.

1. Introduction

Threading is the foundational concept that allows a program to execute multiple tasks concurrently within the same process. In essence, threads are lightweight sub-processes that share the same memory space.

Why is threading useful?

Concurrency: You can perform multiple operations at once, making applications more responsive. For instance, a UI application might keep its interface responsive while performing a lengthy computation in the background.
Resource Sharing: Threads share the same address space and can access the same data, which can lead to more efficient use of resources, provided we manage concurrent access correctly.
Performance: On multi-core processors, multi-threaded applications can run tasks in parallel, which can lead to significant speedups for some tasks.

Advantages of Multithreading:

Improved Throughput: By distributing tasks among multiple threads, you can complete them faster.
Better Resource Utilization: Since threads share resources, you often use less memory than you would with multiple processes.
Smoother User Experiences: For applications with a user interface, background threads can keep the application responsive.

2. Basics of Threads in C++

What is a thread?

A thread, often termed a "lightweight process", is the smallest sequence of programmed instructions that can be managed independently by a scheduler (which is typically a part of the operating system). In simpler words, it's a path of execution within a program.

How do threads differ from processes?

Isolation: Processes are isolated from each other, meaning they don't naturally share memory. In contrast, threads within the same process share the same memory space.
Communication: Inter-process communication (IPC) can be more complex and slower than inter-thread communication because of the isolation between processes.
Overhead: Threads have a lower overhead compared to processes. Starting a new thread is generally faster and requires fewer resources than starting a new process.

The `std::thread` class from the C++ Standard Library:

The std::thread class encapsulates a thread in C++. It provides methods to start a new thread, query its status, and join or detach it.

#include <iostream>
#include <thread>

// A simple function that we'll run in a separate thread
void myFunction() {
    std::cout << "Hello from the new thread!" << std::endl;
}

int main() {
    // Start a new thread that runs myFunction
    std::thread t(myFunction);

    // Do something in the main thread
    std::cout << "Hello from the main thread!" << std::endl;

    // Wait for the new thread to finish
    t.join();

    return 0;
}

In the above example, we create a new thread t that runs myFunction. The main thread continues to execute, printing its message, and then waits for t to finish using t.join().

3. Starting and Stopping Threads

How to start a new thread:

Starting a new thread in C++ is straightforward using the std::thread class. You simply construct a std::thread object and provide it a function or callable object to execute.

#include <iostream>
#include <thread>

void functionToRun() {
    std::cout << "This runs in a separate thread!" << std::endl;
}

int main() {
    std::thread newThread(functionToRun);

    // Do other stuff in the main thread...

    newThread.join();  // Wait for the thread to finish before proceeding.

    return 0;
}

How to gracefully stop a thread:

C++ doesn't provide a built-in way to forcefully stop a thread. Instead, you'll design your threads to check conditions (like flags) to know when they should stop. This is considered a graceful stop because the thread cleans up and exits on its own terms.

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<bool> stopFlag(false);

void functionToRun() {
    while(!stopFlag.load()) {
        // ... Do some work ...

        std::cout << "Working..." << std::endl;

        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "Thread stopped gracefully." << std::endl;
}

int main() {
    std::thread newThread(functionToRun);

    // Let the thread run for a few seconds...
    std::this_thread::sleep_for(std::chrono::seconds(3));

    stopFlag.store(true);  // Signal the thread to stop.

    newThread.join();

    return 0;
}

The `join()` and `detach()` methods:

join(): This method blocks the calling thread (often the main thread) until the thread represented by the std::thread object finishes its execution. If you don't join or detach a thread before its destructor is called, std::terminate will be invoked, which typically ends the program.

cpp std::thread t1(functionToRun); t1.join(); // Wait for t1 to finish.

detach(): This allows the thread to run in the background, freeing the std::thread object from the thread. Once detached, you can't join the thread anymore, and its resources will be automatically released when it finishes.

cpp std::thread t2(functionToRun); t2.detach(); // Let t2 run independently of the main thread.

Remember: It's crucial to decide whether to join() or detach() a thread. Not making a choice can lead to unexpected behavior.

The risks of concurrent data access:

When multiple threads access shared data simultaneously without synchronization, undefined and unpredictable behavior can occur. This is particularly risky when at least one of the threads modifies the data.

Example: Imagine two threads incrementing a shared counter without synchronization. Both threads might fetch the same value (say 5), increment it, and then write back the value 6, when the expected result would be 7.

#include <iostream>
#include <thread>

int sharedCounter = 0;

void incrementCounter() {
    for (int i = 0; i < 100000; ++i) {
        sharedCounter++;
    }
}

int main() {
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);

    t1.join();
    t2.join();

    std::cout << "Expected counter value: 200000" << std::endl;
    std::cout << "Actual counter value: " << sharedCounter << std::endl;

    return 0;
}

The actual counter value will likely not match the expected value due to concurrent modification without synchronization.

Using `std::mutex` to prevent data races:

A mutex (short for "mutual exclusion") is a synchronization primitive that prevents more than one thread from accessing shared data simultaneously. std::mutex provides a way to lock and unlock shared resources.

Modified Example with Mutex:

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

int sharedCounter = 0;
std::mutex counterMutex;

void incrementCounter() {
    for (int i = 0; i < 100000; ++i) {
        counterMutex.lock();
        sharedCounter++;
        counterMutex.unlock();
    }
}

int main() {
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);

    t1.join();
    t2.join();

    std::cout << "Expected counter value: 200000" << std::endl;
    std::cout << "Actual counter value: " << sharedCounter << std::endl;

    return 0;
}

Now, the actual counter value should match the expected value due to the mutex ensuring only one thread modifies the counter at a time.

Deadlocks: what they are and how to avoid them:

A deadlock occurs when two or more threads are unable to proceed with their execution because each of them is waiting for the other to release resources. Essentially, they're stuck in a standstill.

Example of a Deadlock:

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

std::mutex mutex1;
std::mutex mutex2;

void threadFunction1() {
    mutex1.lock();
    std::this_thread::sleep_for(std::chrono::milliseconds(1));  // simulate some work
    mutex2.lock();
    // ... Do some work ...
    mutex2.unlock();
    mutex1.unlock();
}

void threadFunction2() {
    mutex2.lock();
    std::this_thread::sleep_for(std::chrono::milliseconds(1));  // simulate some work
    mutex1.lock();
    // ... Do some work ...
    mutex1.unlock();
    mutex2.unlock();
}

int main() {
    std::thread t1(threadFunction1);
    std::thread t2(threadFunction2);

    t1.join();
    t2.join();

    return 0;
}

In the above example, t1 locks mutex1 and waits for mutex2, while t2 locks mutex2 and waits for mutex1. This leads to a deadlock.

Avoiding Deadlocks: 1. Lock Ordering: Always lock mutexes in the same order. 2. Lock Timeout: Set a timeout when attempting to acquire a lock, and retry if unsuccessful. 3. std::lock(): A C++ function that can lock multiple mutexes without risking deadlock.

// Using std::lock() to avoid deadlock
std::lock(mutex1, mutex2);  // lock both mutexes without deadlock risk
std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);

5. Synchronization Primitives

Mutexes (`std::mutex`):

A mutex (short for "mutual exclusion") ensures that only one thread can access shared data at a time, thereby preventing data races.

Usage:

std::mutex mtx;

void function() {
    mtx.lock();
    // ... critical section ...
    mtx.unlock();
}

However, it's safer to use a lock (like std::lock_guard — discussed later) with a mutex, as it guarantees the mutex is unlocked even if an exception occurs.

Condition variables (`std::condition_variable`):

Condition variables allow threads to wait (block) until a particular condition becomes true. They're often used with a mutex to protect shared data.

Usage:

std::mutex mtx;
std::condition_variable condVar;
bool ready = false;

void functionWait() {
    std::unique_lock<std::mutex> lock(mtx);
    condVar.wait(lock, []{ return ready; });
    // ... proceed once ready becomes true ...
}

void functionSignal() {
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    condVar.notify_one(); // Wake up a waiting thread
}

In this example, functionWait will wait until functionSignal sets ready to true.

Locks:

std::lock_guard: A simple RAII-style mechanism for owning a mutex for the duration of a scoped block.

Usage: cpp std::mutex mtx; void function() { std::lock_guard<std::mutex> guard(mtx); // ... critical section ... } // mtx is automatically released when guard goes out of scope

std::unique_lock: A more flexible RAII-style mechanism. Unlike std::lock_guard, it can be unlocked manually and can be transferred between scopes.

Usage: cpp std::mutex mtx; void function() { std::unique_lock<std::mutex> lock(mtx); // ... do some work ... lock.unlock(); // ... do some work without the lock ... lock.lock(); // ... critical section again ... } // mtx is automatically released if still owned by lock

`std::atomic` and atomic operations:

Atomics provide a mechanism to manipulate variables safely in a multi-threaded environment without the need for mutexes. Atomic operations are operations that run completely independently of any other operations and are uninterruptible.

Usage:

std::atomic<int> atomicCounter(0);

void increment() {
    for (int i = 0; i < 100000; ++i) {
        atomicCounter++;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter value: " << atomicCounter.load() << std::endl;

    return 0;
}

In this example, atomicCounter is safely incremented by two threads without the need for a mutex.

6. Thread Communication

Passing data to and from threads:

When you start a thread, you often need to give it data to work with. Conversely, when a thread finishes its work, you might want to retrieve the results. Passing data to threads and retrieving data from them is a crucial aspect of multi-threading.

Passing Data to a Thread: You can pass arguments to the thread's function much like you would for any other function.

#include <iostream>
#include <thread>

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

int main() {
    std::thread t(printMessage, "Hello from the thread!", 3);
    t.join();
    return 0;
}

Retrieving Data from a Thread: To get data from a thread, you can use std::promise and std::future. A std::promise sets a value from one thread that a std::future can retrieve in another thread.

#include <iostream>
#include <thread>
#include <future>

void calculateProduct(std::promise<int> &&prom, int a, int b) {
    prom.set_value(a * b);  // set the value for the future
}

int main() {
    std::promise<int> prodPromise;
    std::future<int> prodFuture = prodPromise.get_future();

    std::thread t(calculateProduct, std::move(prodPromise), 3, 4);

    int product = prodFuture.get();  // retrieve the value from the thread
    std::cout << "Product: " << product << std::endl;

    t.join();
    return 0;
}

Safe ways to signal between threads:

Threads often need to communicate events, like the completion of tasks. This is known as signaling.

Using std::condition_variable for Signaling: We've previously seen std::condition_variable for waiting until a condition becomes true. This mechanism can also be used for signaling.

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

std::mutex mtx;
std::condition_variable condVar;
bool taskDone = false;

void doTask() {
    std::this_thread::sleep_for(std::chrono::seconds(2));  // simulate work
    {
        std::lock_guard<std::mutex> lock(mtx);
        taskDone = true;
    }
    condVar.notify_one();
}

int main() {
    std::thread t(doTask);

    {
        std::unique_lock<std::mutex> lock(mtx);
        condVar.wait(lock, []{ return taskDone; });
    }

    std::cout << "Task is done!" << std::endl;

    t.join();
    return 0;
}

In the above example, the main thread waits for the doTask thread to signal that the task is done using a condition variable.

7. Thread Pools

What is a thread pool and why might you want one?

A thread pool is a group of pre-initialized threads that stand ready to execute tasks. Instead of creating a new thread every time you need one and then destroying it once finished (which can be costly in terms of time and resources), you pull a thread from the pool, use it for your task, and then return it to the pool when done.

Reasons for Using a Thread Pool: 1. Performance: Thread creation and destruction have overhead. By reusing threads, you avoid this overhead. 2. Resource Management: If each task were to create its own thread, systems could quickly run out of resources. Thread pools prevent this by limiting the number of threads. 3. Throttling: You can control the number of threads that run concurrently. This can be useful when tasks are I/O-bound or when interfacing with systems that have concurrency limits.

Common thread pool patterns in C++:

C++ doesn't have a built-in thread pool in the standard library. However, many libraries and patterns exist to implement thread pools. One common pattern is a "Producer-Consumer" model:

Producers add tasks to a task queue.
Worker threads (consumers) continually check the queue for tasks. When a task is found, they execute it and then return to checking the queue.

Example Implementation (simplified for brevity):

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex mtx;
    std::condition_variable condVar;
    bool stop = false;

public:
    ThreadPool(size_t threads) {
        for(size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while(true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->mtx);
                        this->condVar.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                        if(this->stop && this->tasks.empty()) return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    void enqueue(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            tasks.push(task);
        }
        condVar.notify_one();
    }

    ~ThreadPool() {
        {
            std::lock_guard<std::mutex> lock(mtx);
            stop = true;
        }
        condVar.notify_all();
        for(std::thread &worker: workers) {
            worker.join();
        }
    }
};

int main() {
    ThreadPool pool(4);
    for(int i = 0; i < 10; ++i) {
        pool.enqueue([i] {
            std::cout << "Task " << i << " executed by thread " << std::this_thread::get_id() << std::endl;
        });
    }

    std::this_thread::sleep_for(std::chrono::seconds(2));  // Allow tasks to complete
    return 0;
}

Benefits of using a thread pool:

Efficiency: Reusing threads avoids the overhead of frequently creating and destroying them.
Control: It provides control over how many threads are running concurrently. This is useful to prevent the system from becoming overwhelmed.
Resource Management: Reduces resource consumption and potential system contention by reusing threads and bounding concurrency.
Simplified Concurrency: Eases concurrent programming by abstracting away thread management details. The developer focuses on tasks rather than how threads are handled.

8. Task-based Parallelism

Overview of tasks vs. threads:

Threads: Threads are the smallest unit of a CPU's execution. When you create a thread, you have explicit control over its lifecycle. Threads are low-level constructs, and dealing with them requires manual handling of synchronization, data races, and potential deadlocks.
Tasks: Tasks are higher-level constructs, representing asynchronous operations. Tasks are essentially units of work that should be done but might not run immediately. They could run concurrently, but the system determines the specifics. This abstraction allows for more flexibility as tasks can be mapped to threads based on various strategies, without the programmer worrying about thread management.

Key Difference: While threads offer fine-grained control over concurrent execution, tasks abstract away the details, focusing on the "what" (the computation) instead of the "how" (the thread management).

The std::async and std::future classes:

std::async: - std::async is a function that allows you to run a function asynchronously (potentially in a separate thread) and returns a std::future object. - The system decides if the function should run asynchronously or if it should run synchronously in the calling thread, based on available resources.

Usage:

#include <iostream>
#include <future>

int computeSum(int a, int b) {
    return a + b;
}

int main() {
    std::future<int> result = std::async(computeSum, 5, 3);
    std::cout << "Sum: " << result.get() << std::endl;
    return 0;
}

std::future: - std::future represents a placeholder for a result that will be available in the future. It provides a mechanism to access the result of an asynchronous operation. - You can query a std::future to see if the result is available, wait for the result, or retrieve the result.

Usage: Using the previous example, result.get() fetches the result from the asynchronous operation. It blocks until the result is available.

Key Points: 1. Blocking: The call to result.get() will block if the result is not yet available. It's essential to be aware of this to avoid inadvertently stalling your program. 2. Exception Handling: If the asynchronous function throws an exception, it will be stored in the std::future object. Calling get() will rethrow the exception in the calling thread, so you can catch and handle it.

9. Advanced Topics

Thread-local Storage:

Thread-local storage (TLS) is a mechanism by which each thread in a multithreaded application can have its own separate storage for variables. Instead of sharing variables between threads, each thread has its own copy.

Usage in C++: You can use the thread_local keyword to specify that a particular variable should have storage duration that's specific to each thread.

#include <iostream>
#include <thread>

thread_local int threadSpecificValue = 0;

void incrementAndPrint() {
    ++threadSpecificValue;
    std::cout << "Value: " << threadSpecificValue << " for thread: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t1(incrementAndPrint);
    std::thread t2(incrementAndPrint);
    t1.join();
    t2.join();
    return 0;
}

Thread Affinity and Setting Processor Cores:

Thread affinity refers to binding specific threads to specific CPU cores. It's a mechanism to hint or direct which CPU core a thread should run on. This can be useful in real-time systems, systems with cache considerations, or for optimizing performance on multi-core systems.

C++ standard library doesn't provide direct functionality for setting thread affinity. This often requires platform-specific code or third-party libraries. For example, on Linux, you'd use the pthread_setaffinity_np function.

Exception Handling in Threads:

In a multithreaded C++ program, exceptions thrown inside a thread cannot be caught outside that thread. Instead, they must be caught within the same thread where they were thrown.

Key Points: 1. Uncaught Exceptions: If a thread doesn't catch an exception, the program will terminate. The std::terminate function gets called. 2. Passing Exceptions: If you want the main thread (or another thread) to be aware of and handle an exception thrown in a worker thread, you can use std::promise and std::future or std::async to pass exception information between threads. 3. Handling with std::async and std::future: If a function launched with std::async throws an exception, that exception will be stored. It will then be rethrown in the thread that calls get() on the associated std::future.

#include <iostream>
#include <future>

void mightThrow() {
    throw std::runtime_error("Example exception");
}

int main() {
    std::future<void> result = std::async(mightThrow);

    try {
        result.get();
    } catch(const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }

    return 0;
}

10. Best Practices

Tips for Effective Multithreaded Programming:

Start Simple: Begin with a single-threaded version of your program. Make sure it's correct and then gradually add multithreading.

Example: Before parallelizing a data processing pipeline, ensure the sequential version produces expected results.

Minimize Shared State: The more data shared between threads, the harder it is to maintain thread safety. Aim to keep as much as possible within the local state of each thread.

Example: If two threads need to compute values, try to make them do so independently without needing to access shared variables.

Prefer Higher-Level Abstractions: Instead of manually managing threads, lean on task-based parallelism (like std::async) or concurrency libraries. They encapsulate many complexities.

Example: Use std::async for spawning tasks instead of manually creating threads.

Be Cautious with Locks: Only lock what's necessary, and for as short a time as possible, to minimize contention.

Example: If you're only updating one part of a data structure, don't lock the whole thing—just lock that specific part.

Test with Different Thread Counts: A program might work with two threads but fail with ten. Ensure your program's correctness across different levels of concurrency.

Common Pitfalls and How to Avoid Them:

Race Conditions: Occur when the program's behavior depends on the relative timing of events, such as threads accessing shared data.

Solution: Use synchronization primitives (std::mutex, std::atomic) to ensure consistent access to shared resources.

Example:

std::mutex dataMutex;
int sharedData = 0;

void modifyData() {
    std::lock_guard<std::mutex> lock(dataMutex);
    ++sharedData;
}

Deadlocks: Happen when two or more threads are waiting for each other to finish, creating a cycle of dependencies.

Solution: Always acquire locks in the same order or use std::lock() to acquire multiple locks atomically.

Example of Problem:

std::mutex mutexA, mutexB;

// Thread 1
mutexA.lock();
mutexB.lock();
// ...

// Thread 2
mutexB.lock();
mutexA.lock();
// ...

Solution:

std::lock(mutexA, mutexB);
std::lock_guard<std::mutex> lockA(mutexA, std::adopt_lock);
std::lock_guard<std::mutex> lockB(mutexB, std::adopt_lock);

Starvation: When one or more threads are prevented from running because resources are continually taken by other threads.

Solution: Implement fairness mechanisms or use data structures/libraries that provide fairness guarantees.

Oversubscription: Happens when you have many more threads than cores, leading to context switching overhead.

Solution: Use thread pools to limit the number of active threads or match thread count with available cores.

11. Q&A

1. How do you create and start a thread in C++?

Answer: In C++, you create and start a thread using the std::thread class from the C++ Standard Library. You provide a function or callable object to the thread's constructor, and the thread begins executing that function.

Code Snippet:

#include <iostream>
#include <thread>

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

int main() {
    std::thread myThread(printHello);
    myThread.join();
    return 0;
}

2. What is a mutex and why is it used in multithreading?

Answer: A mutex (short for "mutual exclusion") is a synchronization primitive used to ensure that only one thread can access a resource or a section of code at a time. It's commonly used to prevent race conditions in multithreaded applications.

Code Snippet:

#include <mutex>

std::mutex dataMutex;
int sharedData = 0;

void incrementData() {
    std::lock_guard<std::mutex> lock(dataMutex);
    ++sharedData;
}

3. How do you return a value from a thread?

Answer: To return a value from a thread, you can utilize std::async along with std::future. std::async runs a function asynchronously and returns a std::future object that represents a future result.

Code Snippet:

#include <iostream>
#include <future>

int computeSum(int a, int b) {
    return a + b;
}

int main() {
    std::future<int> result = std::async(computeSum, 5, 3);
    std::cout << "Sum: " << result.get() << std::endl;
    return 0;
}

4. What's the difference between join() and detach() methods of std::thread?

Answer: The join() method makes the calling thread wait for the thread to finish its execution. In contrast, the detach() method allows the thread to run independently in the background. After calling detach(), the thread's resources will be cleaned up automatically once it completes.

5. What is a std::condition_variable and when is it used?

Answer: A std::condition_variable is a synchronization primitive used in conjunction with a mutex to allow threads to wait (block) until a particular condition becomes true. It's often used for scenarios like producer-consumer problems.

Code Snippet:

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>

std::queue<int> dataQueue;
std::mutex queueMutex;
std::condition_variable condVar;

void produce() {
    for (int i = 0; i < 5; ++i) {
        std::lock_guard<std::mutex> lock(queueMutex);
        dataQueue.push(i);
        condVar.notify_one();
    }
}

void consume() {
    for (int i = 0; i < 5; ++i) {
        std::unique_lock<std::mutex> lock(queueMutex);
        condVar.wait(lock, [](){ return !dataQueue.empty(); });
        int value = dataQueue.front();
        dataQueue.pop();
        lock.unlock();
        std::cout << "Consumed: " << value << std::endl;
    }
}

int main() {
    std::thread producerThread(produce);
    std::thread consumerThread(consume);
    producerThread.join();
    consumerThread.join();
    return 0;
}

6. How can you ensure that multiple threads don't enter a critical section simultaneously?

Answer: Use a std::mutex to guard the critical section. A critical section is a portion of code where access to shared resources must be serialized. By locking the mutex before entering the critical section and unlocking it after leaving, you ensure only one thread can execute that section of code at a time.

Code Snippet:

std::mutex criticalSectionMutex;

void criticalFunction() {
    std::lock_guard<std::mutex> lock(criticalSectionMutex);
    // ... critical section code ...
}

7. What is the purpose of std::once_flag and std::call_once?

Answer: std::once_flag and std::call_once are used to ensure that a piece of code is executed only once, even when called from multiple threads. This is particularly useful for thread-safe lazy initialization.

Code Snippet:

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

std::once_flag flag;

void initialize() {
    std::cout << "Initialized once!" << std::endl;
}

void threadFunction() {
    std::call_once(flag, initialize);
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    return 0;
}

8. How can you pass arguments to a thread function?

Answer: Arguments can be passed to a thread function by passing them to the std::thread constructor after the function pointer.

Code Snippet:

#include <iostream>
#include <thread>

void greet(const std::string& name) {
    std::cout << "Hello, " << name << "!" << std::endl;
}

int main() {
    std::thread greetingThread(greet, "Alice");
    greetingThread.join();
    return 0;
}

9. How do you handle exceptions in a thread?

Answer: Exceptions thrown in a thread will not be caught by the main thread directly. Instead, if an exception is not caught within the thread function, std::terminate is called. To propagate exceptions to the main thread or another thread, you can use std::async and std::future. When you call get() on a std::future, it will rethrow any exception thrown in the associated thread.

Code Snippet:

#include <iostream>
#include <future>

void mayThrowException(bool shouldThrow) {
    if (shouldThrow) {
        throw std::runtime_error("An error occurred!");
    }
}

int main() {
    auto future = std::async(std::launch::async, mayThrowException, true);
    try {
        future.get();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}

10. What is std::thread::hardware_concurrency() and what does it return?

Answer: std::thread::hardware_concurrency() returns the number of concurrent threads supported by the system, which is typically the number of CPU cores. This can be useful when deciding how many threads to create for optimal performance. However, note that the value is just a hint and can be 0 if the information is not available.

Code Snippet:

#include <iostream>
#include <thread>

int main() {
    unsigned int nCores = std::thread::hardware_concurrency();
    std::cout << "Supported concurrent threads: " << nCores << std::endl;
    return 0;
}

11. What is a std::recursive_mutex? How is it different from std::mutex?

Answer: A std::recursive_mutex is a type of mutex that allows the same thread to lock it multiple times without causing a deadlock, unlike std::mutex. This can be useful when a function that locks a mutex can be called recursively or be called from another function that already holds the same mutex lock.

Code Snippet:

std::recursive_mutex recursiveMutex;

void recursiveFunction(int depth) {
    if (depth <= 0) return;

    std::lock_guard<std::recursive_mutex> lock(recursiveMutex);
    // ... some code ...
    recursiveFunction(depth - 1);
}

12. What is the difference between std::lock_guard and std::unique_lock?

Answer: Both are RAII-style locks for mutexes. The key differences are: 1. std::lock_guard locks the mutex on construction and unlocks on destruction, and it cannot be manually unlocked or deferred. 2. std::unique_lock is more flexible. It can defer locking, be manually locked or unlocked, and can transfer ownership of the lock.

Code Snippet:

std::mutex mtx;

// Using lock_guard
{
    std::lock_guard<std::mutex> guard(mtx);
    // mtx is now locked
} // mtx is automatically unlocked here

// Using unique_lock
{
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
    // Lock manually
    lock.lock();
    // mtx is now locked
    lock.unlock();
    // mtx is now unlocked
}

13. Why is std::this_thread::yield() used and what does it do?

Answer: std::this_thread::yield() is a hint to the processor that the current thread is willing to release its current time slice and allow other threads to run. It's useful in situations where a thread is in a busy-wait spin loop and might want to yield to let other threads progress.

Code Snippet:

while(!some_condition_met) {
    std::this_thread::yield(); // give other threads a chance to run
}

14. How can you ensure a specific order of execution between threads?

Answer: You can use synchronization primitives like std::mutex, std::condition_variable, or std::barrier to ensure a specific order of execution or coordination between threads.

Code Snippet:

std::mutex mtx;
std::condition_variable cv;
bool isReady = false;

void thread1() {
    std::unique_lock<std::mutex> lock(mtx);
    // ... do some work ...
    isReady = true;
    cv.notify_one();
}

void thread2() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [](){ return isReady; });
    // ... continue after thread1 has set isReady ...
}

15. What's the purpose of std::thread::native_handle()?

Answer: std::thread::native_handle() returns a handle to the underlying thread representation, which is platform-specific. This can be used to set or query low-level thread attributes not directly supported by the C++ Standard Library. However, using it makes your code less portable.

Code Snippet:

// This example is platform-dependent and might not be portable
#include <thread>
#include <pthread.h>

void setThreadPriority(std::thread& th, int priority) {
    pthread_t nativeHandle = th.native_handle();
    sched_param sch_params;
    sch_params.sched_priority = priority;
    pthread_setschedparam(nativeHandle, SCHED_FIFO, &sch_params);
}

int main() {
    std::thread myThread([]{ /* some work */ });
    setThreadPriority(myThread, 10);
    myThread.join();
    return 0;
}

16. What's the difference between std::async, std::thread and std::packaged_task?

Answer: - std::thread: Launches a new thread of execution. - std::async: Asynchronously evaluates a function and returns a std::future that will eventually hold the result of that evaluation. - std::packaged_task: Represents a packaged task, which is a callable object that, when invoked, will allow retrieving its result (or exception) through a std::future.

Code Snippet:

// Using std::thread
std::thread th([]{ std::cout << "Thread executed." << std::endl; });
th.join();

// Using std::async
auto future = std::async([]{ return "Async executed."; });
std::cout << future.get() << std::endl;

// Using std::packaged_task
std::packaged_task<std::string()> task([]{ return "Task executed."; });
auto result = task.get_future();
task();
std::cout << result.get() << std::endl;

17. How can you avoid a race condition when reading shared data?

Answer: Use synchronization mechanisms like std::mutex, std::shared_mutex (for reader-writer locks), or atomic operations to safely read shared data.

Code Snippet:

std::shared_mutex rwMutex;
int sharedData = 0;

void readData() {
    std::shared_lock<std::shared_mutex> lock(rwMutex);
    std::cout << sharedData << std::endl;
}

18. How does std::atomic ensure atomic operations?

Answer: std::atomic provides a template class that guarantees atomic operations on the underlying type, ensuring that operations are completed in a single step without being interrupted.

Code Snippet:

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 10000; ++i) {
        counter++;
    }
}

19. What's the role of std::condition_variable_any? How does it differ from std::condition_variable?

Answer: std::condition_variable_any is a generalization of std::condition_variable. While std::condition_variable works specifically with std::unique_lock<std::mutex>, std::condition_variable_any can work with any lock that implements the lock() and unlock() methods.

Code Snippet:

std::mutex mtx;
bool ready = false;
std::condition_variable_any cv_any;

void waitAndPrint() {
    std::unique_lock<std::mutex> lock(mtx);
    cv_any.wait(lock, []{ return ready; });
    std::cout << "Ready!" << std::endl;
}

20. What are the potential problems of over-threading, and how can they be mitigated?

Answer: Over-threading occurs when an application creates more threads than can be efficiently managed by the system, leading to issues like increased context switching, contention, and memory overhead. To mitigate these problems: 1. Limit the number of threads based on the system's capabilities (e.g., std::thread::hardware_concurrency()). 2. Use thread pools to reuse existing threads. 3. Use task-based parallelism where tasks can be efficiently scheduled on available threads.

Code Snippet:

unsigned int maxThreads = std::thread::hardware_concurrency();
std::cout << "Optimal number of threads: " << maxThreads << std::endl;

Threading

1. Introduction

Why is threading useful?

Advantages of Multithreading:

2. Basics of Threads in C++

What is a thread?

How do threads differ from processes?

The std::thread class from the C++ Standard Library:

3. Starting and Stopping Threads

How to start a new thread:

How to gracefully stop a thread:

The join() and detach() methods:

4. Thread Safety and Data Sharing

The risks of concurrent data access:

Using std::mutex to prevent data races:

Deadlocks: what they are and how to avoid them:

5. Synchronization Primitives

Mutexes (std::mutex):

Condition variables (std::condition_variable):

Locks:

std::atomic and atomic operations:

6. Thread Communication

Passing data to and from threads:

Safe ways to signal between threads:

7. Thread Pools

What is a thread pool and why might you want one?

Common thread pool patterns in C++:

Benefits of using a thread pool:

8. Task-based Parallelism

Overview of tasks vs. threads:

The std::async and std::future classes:

9. Advanced Topics

Thread-local Storage:

Thread Affinity and Setting Processor Cores:

Exception Handling in Threads:

10. Best Practices

Tips for Effective Multithreaded Programming:

Common Pitfalls and How to Avoid Them:

11. Q&A

The `std::thread` class from the C++ Standard Library:

The `join()` and `detach()` methods:

Using `std::mutex` to prevent data races:

Mutexes (`std::mutex`):

Condition variables (`std::condition_variable`):

`std::atomic` and atomic operations: