Simple example of threading in C++

In C++, starting from C++11, the standard library provides support for threads. This allows us to use the functionalities provided by the <thread> header to create and manage threads. I will demonstrate how to create two threads, each outputting a sequence of numbers, through a simple example.

Example Code

cpp
#include <iostream>
#include <thread>

// Define a function to be executed by the thread
void printNumbers(int start, int end) {
    for (int i = start; i <= end; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main() {
    // Create two threads
    std::thread t1(printNumbers, 1, 5);
    std::thread t2(printNumbers, 6, 10);

    // Wait for both threads to complete
    t1.join();
    t2.join();

    std::cout << "All threads have completed their work" << std::endl;

    return 0;
}

Code Analysis

1. Include necessary header files:

   • <iostream>: for input and output operations.
   • <thread>: for creating and managing threads.

2. Define the function to be executed by threads:

   • The printNumbers function accepts two integer parameters to print a sequence of numbers from start to end.

3. Create and start threads:

   • In the main function, we create two threads t1 and t2, each executing the printNumbers function with different parameters.

4. Wait for threads to complete:

   • Using the join() method, the main thread waits for threads t1 and t2 to complete their tasks.

Output Result

shell
1 2 3 4 5 
6 7 8 9 10 
All threads have completed their work

Notes

• The execution order of threads is not fixed; the order of the output may vary depending on how the operating system schedules the threads.
• When using threads, it is important to consider data sharing and synchronization issues to avoid data races and other concurrency problems.

This example demonstrates how to use the thread functionality in the C++ standard library to perform simple parallel tasks.

In C++11 and later versions, C++ introduced native multithreading support, including the thread library. This means you can directly create and manage threads in C++ without relying on operating system-specific APIs.

Here is a simple example demonstrating how to create a thread and execute a function in C++:

cpp
#include <iostream>
#include <thread>

// This is the function to be executed in the thread
void threadFunction() {
    std::cout << "Thread starts executing" << std::endl;
    // Perform some operations...
    std::cout << "Thread ends executing" << std::endl;
}

int main() {
    std::cout << "Main thread starts" << std::endl;

    // Create a thread to run the threadFunction function
    std::thread t(threadFunction);

    // In the main thread, wait for the newly created thread to complete
    t.join();

    std::cout << "Main thread ends" << std::endl;
    return 0;
}

In this example, we first include the <thread> header file, which is necessary for using the C++ thread library. We then define a function named threadFunction, which is the code we want to execute in the new thread. In the main function, we create a std::thread object t, which starts executing the threadFunction function upon construction. By calling t.join(), the main thread waits for the newly created thread to complete before proceeding, ensuring thread synchronization.

This simple example demonstrates how to use the C++ standard library to create and manage threads. The advantage is that the code is portable and does not depend on the thread management mechanisms of specific operating systems.