Skip to Content
šŸ‘† We offer 1-on-1 classes as well check now

Threads in C++

Multithreading allows a program to execute multiple parts of its code concurrently. This is achieved by dividing the program into independent, concurrently running units called threads. In C++, the <thread> header provides the necessary tools to create and manage threads, enabling developers to leverage the power of modern multi-core processors for improved performance and responsiveness. This document provides an in-depth exploration of threads in C++, covering everything from basic thread creation to advanced synchronization techniques and best practices.

What are Threads in C++

In essence, a thread represents an independent flow of execution within a process. Unlike processes, threads within the same process share the same memory space, which enables efficient communication and data sharing. However, this shared memory also necessitates careful synchronization to prevent race conditions and data corruption.

In-depth Explanation:

  • Concurrency vs. Parallelism: Itā€™s important to distinguish between concurrency and parallelism. Concurrency refers to the ability of a program to handle multiple tasks at the same time (potentially by interleaving their execution on a single core), while parallelism refers to the ability of a program to execute multiple tasks simultaneously on multiple cores. Threads can achieve both concurrency and parallelism, depending on the underlying hardware.

  • Thread Lifecycle: A thread goes through several states:

    • New: The thread has been created but not yet started.
    • Runnable: The thread is ready to be executed by the operating system.
    • Running: The thread is currently executing.
    • Blocked/Waiting: The thread is waiting for a resource or event (e.g., a mutex, a condition variable, I/O completion).
    • Terminated: The thread has finished execution.

  • Context Switching: When multiple threads are running on a single core, the operating system rapidly switches between them, giving each thread a small slice of CPU time. This is known as context switching, and it introduces overhead that can impact performance.

  • Performance Considerations: Multithreading can significantly improve performance for CPU-bound tasks that can be divided into independent subtasks. However, it can also introduce overhead due to context switching, synchronization, and increased complexity. Careful design and profiling are essential to ensure that multithreading actually improves performance. Itā€™s crucial to analyze if the overhead of thread creation, management, and synchronization outweighs the benefits of parallel execution.

  • Edge Cases:

    • False Sharing: Occurs when threads operating on different data reside on the same cache line. Even though the data is logically separate, modifications by one thread will invalidate the cache line for other threads, leading to performance degradation.
    • Deadlocks: Occur when two or more threads are blocked indefinitely, waiting for each other to release resources.
    • Livelocks: Similar to deadlocks, but threads are not blocked; instead, they are continuously changing their state in response to each otherā€™s actions, preventing any progress.
    • Priority Inversion: A high-priority thread is blocked by a low-priority thread holding a resource that the high-priority thread needs.

Syntax and Usage

The <thread> header provides the std::thread class for creating and managing threads.

Creating a Thread:

#include <iostream>
#include <thread>
 
void task(int id) {
    std::cout << "Thread " << id << " executing\n";
}
 
int main() {
    std::thread t1(task, 1); // Creates a thread that executes the task function with argument 1
    std::thread t2(task, 2);
 
    t1.join(); // Waits for t1 to finish
    t2.join(); // Waits for t2 to finish
 
    std::cout << "Main thread exiting\n";
    return 0;
}

Key Methods:

  • std::thread(callable, args...): Constructs a new thread and starts executing the callable object (function, lambda, function object) with the provided arguments.
  • join(): Blocks the calling thread until the thread being joined completes its execution. Calling join() is crucial to avoid undefined behavior when the std::thread object goes out of scope.
  • detach(): Separates the thread from the std::thread object, allowing it to continue executing independently. The thread becomes the responsibility of the operating system, and the std::thread object no longer controls its lifetime. Use with caution.
  • joinable(): Returns true if the thread is joinable (i.e., it hasnā€™t been joined or detached).
  • get_id(): Returns the threadā€™s ID.
  • hardware_concurrency(): Returns the number of hardware thread contexts available on the system. This can be used to determine the optimal number of threads to create.

Basic Example

This example demonstrates a simple multi-threaded program that calculates the sum of elements in an array by dividing the work among multiple threads.

#include <iostream>
#include <thread>
#include <vector>
#include <numeric>
 
const int ARRAY_SIZE = 1000000;
const int NUM_THREADS = 4;
 
void sum_partial(const std::vector<int>& data, int start, int end, long long& result) {
    long long partial_sum = 0;
    for (int i = start; i < end; ++i) {
        partial_sum += data[i];
    }
    result = partial_sum;
}
 
int main() {
    std::vector<int> data(ARRAY_SIZE);
    std::iota(data.begin(), data.end(), 1); // Fill with 1, 2, 3, ...
 
    std::vector<std::thread> threads(NUM_THREADS);
    std::vector<long long> partial_sums(NUM_THREADS);
 
    int chunk_size = ARRAY_SIZE / NUM_THREADS;
 
    for (int i = 0; i < NUM_THREADS; ++i) {
        int start = i * chunk_size;
        int end = (i == NUM_THREADS - 1) ? ARRAY_SIZE : (i + 1) * chunk_size;
        threads[i] = std::thread(sum_partial, std::ref(data), start, end, std::ref(partial_sums[i]));
    }
 
    for (int i = 0; i < NUM_THREADS; ++i) {
        threads[i].join();
    }
 
    long long total_sum = std::accumulate(partial_sums.begin(), partial_sums.end(), 0LL);
    std::cout << "Total sum: " << total_sum << std::endl;
 
    return 0;
}

Explanation:

  1. Initialization: The code initializes a vector data with a large number of integers.
  2. Thread Creation: It creates NUM_THREADS threads. Each thread is assigned a portion of the data vector to sum.
  3. sum_partial Function: This function calculates the sum of a portion of the data vector. It takes the data vector, a start index, an end index, and a reference to a long long variable to store the partial sum. The std::ref is used to pass data and partial_sums[i] by reference, allowing the thread to modify the original variables.
  4. Joining Threads: The join() method is called on each thread to wait for it to complete before proceeding.
  5. Calculating Total Sum: After all threads have finished, the partial sums are added together to calculate the total sum.
  6. Output: The total sum is printed to the console.

Advanced Example

This example demonstrates the use of a thread pool to execute multiple tasks concurrently. This pattern is very useful for handling asynchronous operations or processing a queue of tasks.

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
 
class ThreadPool {
public:
    ThreadPool(size_t num_threads) : stop(false) {
        threads.resize(num_threads);
        for (size_t i = 0; i < num_threads; ++i) {
            threads[i] = std::thread([this]() {
                while (true) {
                    std::function<void()> task;
 
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        cv.wait(lock, [this]() { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = tasks.front();
                        tasks.pop();
                    }
 
                    task();
                }
            });
        }
    }
 
    template<typename F>
    void enqueue(F f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(f);
        }
        cv.notify_one();
    }
 
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        cv.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }
 
private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable cv;
    bool stop;
};
 
int main() {
    ThreadPool pool(4);
 
    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i]() {
            std::cout << "Task " << i << " executing on thread " << std::this_thread::get_id() << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        });
    }
 
    std::this_thread::sleep_for(std::chrono::seconds(2)); // Allow tasks to complete
 
    return 0;
}

Common Use Cases

  • Parallel Processing: Dividing large computational tasks into smaller subtasks that can be executed concurrently.
  • Asynchronous Operations: Handling long-running operations (e.g., I/O, network requests) in the background to prevent blocking the main thread.
  • GUI Responsiveness: Offloading computationally intensive tasks from the GUI thread to prevent the application from freezing.
  • Web Servers: Handling multiple client requests concurrently.

Best Practices

  • Minimize Shared Data: Reduce the amount of data shared between threads to minimize the need for synchronization.
  • Use RAII for Locks: Employ RAII (Resource Acquisition Is Initialization) to ensure that locks are automatically released when they go out of scope, preventing deadlocks. Use std::lock_guard or std::unique_lock.
  • Prefer Higher-Level Abstractions: Use higher-level concurrency abstractions like std::future, std::promise, and std::packaged_task to simplify asynchronous programming.
  • Avoid Busy-Waiting: Use condition variables (std::condition_variable) to efficiently wait for events instead of repeatedly checking a condition.
  • Profile Your Code: Measure the performance of your multi-threaded code to identify bottlenecks and optimize accordingly.

Common Pitfalls

  • Race Conditions: Occur when multiple threads access and modify shared data concurrently without proper synchronization, leading to unpredictable results.
  • Deadlocks: Occur when two or more threads are blocked indefinitely, waiting for each other to release resources.
  • Data Races: A specific type of race condition where at least one thread is writing to a shared memory location while another thread is reading or writing to the same location concurrently. Data races are undefined behavior and can lead to crashes or data corruption.
  • Forgetting to join() or detach(): Failing to either join() or detach() a thread before the std::thread object goes out of scope results in program termination.
  • Over-Synchronization: Excessive use of locks can introduce unnecessary overhead and reduce performance.
  • False Sharing: Performance degradation due to threads operating on logically separate data that happen to reside on the same cache line.

Key Takeaways

  • Threads enable concurrent execution of code, improving performance and responsiveness.
  • Proper synchronization is crucial to prevent race conditions and data corruption when sharing data between threads.
  • The <thread> header provides the necessary tools for creating and managing threads in C++.
  • Careful design and profiling are essential to ensure that multithreading actually improves performance.
  • Understanding common pitfalls like race conditions and deadlocks is crucial for writing robust and reliable multi-threaded code.
Last updated on