Thread Management with `std::thread`

What is a Thread?

So far, all the programs you've written have been single-threaded. Execution starts at main() and proceeds sequentially, one instruction at a time. A thread is an independent sequence of execution within a program. Using multiple threads allows a program to perform several tasks concurrently.

Your computer's CPU has multiple cores, each capable of executing instructions simultaneously. True parallelism occurs when different threads run on different cores at the exact same time. Concurrency is a broader concept where multiple tasks make progress over the same period, even on a single core, by rapidly switching between them.

Let's watch a short video that clarifies this distinction with some helpful analogies.

For our telemetry project, the goal is to achieve true parallelism:

• Thread A (Main Application Thread): Runs the primary logic of the application being profiled.
• Thread B (Consumer Thread): Runs in parallel, reading data that Thread A produces and preparing it for visualization.

Creating Your First Thread with std::thread

C++ provides a standard, platform-independent way to work with threads through the <thread> header and the std::thread class.

Creating a thread is straightforward: you instantiate a std::thread object and pass it a callable entity—something that can be executed, like a function—along with any arguments it needs. The thread begins execution immediately upon creation.

Let's see this in action.

As the video demonstrates, there are two key steps:

1. Creation: std::thread my_thread(function_to_run);
2. Joining: my_thread.join();

The join() call is essential. It instructs the calling thread (in this case, the main thread) to block and wait until my_thread has finished its execution. If you create a thread and don't join() it, the std::thread object's destructor will be called when it goes out of scope. An active, unjoined thread will cause your program to terminate abruptly.

Here is a simple, complete example:

#include <iostream>
#include <thread>

// This function will be executed by our new thread
void worker_function() {
    std::cout << "Worker thread is running." << std::endl;
}

int main() {
    std::cout << "Main thread: starting worker thread." << std::endl;

    // Create a new thread and pass it our worker function
    std::thread worker_thread(worker_function);

    std::cout << "Main thread: continuing execution." << std::endl;

    // Wait for the worker thread to finish before main() exits
    worker_thread.join();

    std::cout << "Main thread: worker thread has finished. Exiting." << std::endl;

    return 0;
}

When you run this, the output from the main and worker threads will be interleaved. The OS scheduler determines which thread runs when, so the exact order isn't guaranteed, but join() ensures the "worker thread has finished" message always comes before "Exiting."

The slide deck "Multi-Threading in C++" from the Technical University of Munich reinforces this critical rule. Slide 646 shows an example where a thread object's lifetime ends without join() being called, leading to program termination.

Managing Thread Lifecycle: join() vs. detach()

Every std::thread you create must be either joined or detached before its destructor is called.

• join(): As we've seen, this creates a synchronization point. The parent thread waits for the child thread to complete. This is the most common and safest way to manage threads.

• detach(): This severs the connection between the std::thread object and the actual thread of execution. The thread becomes a "daemon" process that runs in the background. The std::thread object is no longer associated with it and cannot be joined. This is useful for "fire-and-forget" tasks, but it's dangerous. You, the programmer, are now responsible for ensuring the detached thread doesn't access data that has gone out of scope. For our project, we will favor more explicit lifetime management over detach().

This diagram provides a clear visual model of the two approaches.

To prevent errors like joining a thread twice, you can check if a thread is joinable:

if (my_thread.joinable()) {
    my_thread.join();
}

void launch_worker() {
    std::thread t([](){ /* do some work for 5 seconds */ });
    // What happens here?
}

int main() {
    launch_worker();
    return 0;
}

Threads in Action: Passing Data and Observing Behavior

Threads become much more useful when they can operate on data. You can pass arguments to your thread's function just by adding them to the std::thread constructor.

Let's watch another segment that demonstrates this and also highlights a common beginner mistake.

The <thread> header also provides the std::this_thread namespace, which contains utilities for interacting with the current thread.

• std::this_thread::get_id(): Returns a unique ID for the current thread.
• std::this_thread::sleep_for(): Pauses the current thread for a specified duration.

Let's see how these are used to prove we are running on different threads and to control the pace of execution.

A Practical Example: The Background Worker

The concepts we've discussed—a background thread performing work without blocking the main thread—are perfectly illustrated in a final example. This next video segment builds a small weather application where a background worker thread periodically fetches new data, while the main thread (which would handle the UI) remains responsive.

This is an almost perfect analogy for our telemetry engine's consumer thread, which will periodically poll the ring buffers for new profiling data.

Conclusion

Congratulations on completing your first step into concurrent programming! You now have the foundational knowledge to spawn and manage separate threads of execution, a skill that is absolutely essential for any systems programmer.

Key Takeaways:

• Multithreading allows a program to perform tasks concurrently, which is vital for performance and responsiveness.
• You can create a thread by including <thread> and constructing a std::thread object with a callable and its arguments.
• A std::thread object must be either joined or detached before it goes out of scope to avoid program termination. join() is the safer, more common choice.
• The std::this_thread namespace provides utilities like get_id() and sleep_for() to manage the current thread of execution.
• The background worker pattern, where one thread performs periodic work without blocking the main thread, is a core pattern we will use in our telemetry engine.

In our next lesson, we will confront the biggest challenge in concurrent programming: data races and race conditions. Now that we know how to get multiple threads running, we must learn how to make them safely share and modify data. This will lead us directly to the concept of the std::mutex.