Threading in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand the concept of threading in C++
Demonstrate their knowledge on the use of threading in C++

Threading

Threading (1)

Recap:
- Thread refers to a basic unit of CPU utilisation
  - a separate process that has its own instructions and data
  - it may also represent a process that is part of a parallel program
    - although it may also represent an independent program
- They share their code, data and other operating system resources with other threads belonging to the same process
- A traditional process will have a single thread of control
  - if a process has multiple threads of control, then it has the ability to perform more than one task at a time
Threading on C++ uses the following libraries:
- thread: cross-platform compatible, limited functionality
- pthread.h: Linux and MacOS compatible

You were previously introduced to threading earlier in this module, but for the Python programming language. In that lecture, we covered in-depth the theory and concept behind threading and why it is important. However, to recap, let’s give a very brief overview of what a thread is.

The term ‘thread’ refers to a basic unit of CPU utilisation, this is a separate process that will consist of its own instruction and data. It could represent a process that is a part of a parallel program, or it could also be represented as an independent program or script. Simply, a thread is a separate flow of execution, which means that the script can perform two actions at once.

A multithreaded program can contain two or more parts that run in concurrency, whereby each part of the program is called a thread, and each of these threads defines a separate path of execution. In C++ there are two libraries often used for threading, and these are thread and pthread with the latter more exclusive towards Unix-based operating systems.

`thread` Library

`thread` Library (1)

Creating a Thread

The thread library is required and can be imported using the #include declaration
The function thread() is used to create a thread

#include <thread>
std::thread(func, arg);

Accepts two parameters:
- func: the function that will be threaded
- arg: the arguments that need to be passed through to the threaded function
The join() function is used to wait for a thread to finish
- must be called exactly one for each thread
- must be called before a thread is destroyed

The first library that we shall be exploring is thread. This would be the best method in order to use threads platform independent as it works on Linux, macOS, and Windows. It may require additional compiler flags to be set depending on the underlying implementation.

To use the thread library, it needs to be imported using the include declarative, which would be located at the top of the C++ header or source file. We can then use the thread function to create our thread. The function will accept two parameters, one called func which will be used to pass through the function we want threaded, and the other called arg which will be the arguments we want to pass through to our threaded function. That is if the function were to contain parameters in the first instance. The thread will be terminated once our function has returned some data to it.

`thread` Library (2)

Example: Creating and Terminating a Thread

#include <thread>
#include <iostream>
void threaded_function(const std::string& text) {
    std::cout << std::endl << std::endl << "[Thread ID: " << std::this_thread::get_id() << "] " << text;
}
int main() {
    std::thread t = std::thread(threaded_function, "Threading is fun in 5062CEM!");
    std::thread t2 = std::thread(threaded_function, "Threading is also fun in 5069CEM!");
    t.join();
    t2.join();
    return 0;
}



[Thread ID: 140511885125312] Threading is also fun in 5069CEM!

[Thread ID: 140511893518016] Threading is fun in 5062CEM!

Let’s have a look at an example of how a thread can be constructed, using a function that accepts a single parameter. In this example, we have a function aptly named threaded_function and it accepts a single parameter called text. The purpose of this function is to print the text that has been passed through to the terminal window, along with the ID of the thread. To get the ID of our thread, we shall be using the this_thread namespace, more on this later.

Inside our main function, we can now look at the process of creating our threads. For this example, we shall be creating two threads, one named t and the other t2. Each thread will be passed through a different string to be displayed in the terminal window.

To create our thread, we need to call our data type thread, followed by a variable name. For the purpose of this explanation we shall call our thread t. Once we have declared our thread and its associating data type, we then need to call the thread function. You will recall from the previous slide that our thread function accepts two parameters, one for the name of the thread we want to call, in this case threaded_function is the name of our thread, and the text that we want ti print to the screen. For this example, the text I want printin to the screen is Threading is fun in 5062CEM!.

The same process is also done for our second thread t2. Once both threads have been created, we are then required to use the join function on both threads to ensure that we wait for our thread to finish terminating. You will see from the output on the screen that two threads were created, as the thread IDs have changed, and they were executed in parallel.

`thread` Library (3)

`this_thread` Namespace

The namespace this_thread can be used access properties for a given thread
- get_id(): returns the ID of the running thread
- sleep_until(): sleeps for a given amount of time using time_point
- sleep_for(): sleeps for a given amount of time using duration

On the previous slide I briefly touched upon using the namespace this_thread. This namespace can be used to access the properties for a given thread. Some common functions associated with this namespace are the following:

get_id(): this function will return the ID associated with the running thread
sleep_until(): when provided with an argument, can be used for a given amount of time to sleep the thread
sleep_for(): a similar function to the previous one, but uses a different parameter to put the thread to sleep

When we use the term sleep, we are concerned with blocking the execution of a thread for the number specified from the argument.

`thread` Library (4)

Killing a Thread

There is no official method of killing a thread using the thread library
If necessary, the developer will provide their own solution

`pthread` Library

`pthread` Library (1)

Creating a Thread

The pthread.h library is required and can be imported using the #include declaration
The function pthread_create() is used to create a thread

#include <pthread.h>
pthread_create(thread, attr, start_routine, arg);

Accepts four parameters:
- thread: an opaque and unique identifier for a new thread returned by the subroutine
- attr: an opaque attribute object that can be used to set the thread attributes
- start_routine: the C++ routine that will execute the thread once it has been created
- arg: a single argument that may be passed to the start_routine
Terminating a thread is achieved by calling the pthread_exit() function
- often called when the thread has completed its work
- used when the thread is no longer required to exist

#include <pthread.h>
pthread_exit(status);

Accepts a single parameter:
- status: normally provided a nullptr

The next library for handling threads that we shall look at is pthread, and can only be used on the Linux and macOS platforms. Therefore, if you’re concerned with creating an application that is platform independent, then you may want to revisit the last few slides and use the thread library.

When it comes to creating threads with this library we can use the pthread_create function. It has been designed to accept four parameters. The first parameter is thread and this is a unique identifier for labelling the thread that will be returned by the subroutine. The second parameter is attr, which is short for attributes, and is used to set any attributes that belong to that specific thread.

The third parameter is the start_routine and this is the function that needs to be executed for the given thread. Finally, the kast parameter is arg, and these are the relevant arguments that are required to be passed through for the function that has been declared in the start_routine parameter.

Unlike the thread module, pthread provides an option for you to terminate your threads. This can be achieved by calling the pthread_exit function. This will often be called when the thread has finished executing the code or completed its work, and will be used to delete the thread from memory when it is no longer required to exist.

The function, pthread_exit accepts a single parameter, called status. This is normally provided with the value nullptr and will terminate the thread.

`pthread` Library (2)

Example: Creating and Terminating a Thread

#include <iostream>
#include <pthread.h>
#include <mutex>
#define NUM_THREADS 2
struct arg_struct {
    char* arg1;
};
void* threaded_function(void* arguments) {
    auto* args = (struct arg_struct*) arguments;
    static std::mutex lock;
    std::lock_guard guard{lock};
    std::cout << "[Thread ID: " << pthread_self() << "] " << args->arg1 << std::endl;
    pthread_exit(nullptr);
}
int main() {
    pthread_t threads[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; i++) {
        arg_struct args{"Threading with 5062CEM is fun!"};
        pthread_create(&threads[i], nullptr, threaded_function, (void*) &args);
    }
    pthread_exit(nullptr);
    return 0;
}

[Thread ID: 139934411257536] Threading with 5062CEM is fun!
[Thread ID: 139934402864832] Threading with 5062CEM is fun!

When it comes to creating threads using the pthread library, it becomes a little more complex. The example provided on the screen is over-engineered, as I have created a struct to handle multiple arguments we might want to pass through to our threaded function. A struct in C++ is a structure that enables you to group several related variables together into one place. Each variable that is inside the structure is known as a member of that structure.

To create our structure, we use the struct keyword and declare each of the members inside a set of curly brackets. On the screen, you will see that the structure I have created is called arg_struct, and it contains a single member called arg1 which is a pointer type for a character data type. The char* in this instance is used to point to the first character in the character array, and the char* will be used to iterate through a character array.

Below our structure, we have the function that we shall want to use on multiple threads, aptly named threaded_function. As this function will not be concerned with returning data, it has been created with the void keyword. The parameters for our function are also void as this is the expected method of passing through arguments from the pthread_create function. Therefore, we need a method of converting our arguments being passed through back to their original type.

This can be achieved by a process known as type casting, something you should be familiar from your first year programming module. To type-case in C++, we supply the data type in a set of brackets followed by the name of the variable. In this case, the first line of threaded_function shows how we are type casting our argument parameter back to the structure type we created earlier.

Below the type casting, we have used a mutex. A mutex in C++ is a lockable object that has been designed in a manner to signal when critical sections of code need exclusive access. In this case, the cout function has not been designed to be used with threads, and if a mutex lock was not applied, we would have some quirks to the output. Therefore, we have used a mutex to ensure that our output prints correctly to the screen.

After our mutex lock, we have our print statement using cout, which will print the ID of our thread, and the argument that we passed through. In this case, the argument we are passing through is a string. Finally, the last thing inside our threaded_function is the pthread_exit function which terminates our thread from executing once it has finished processing.

Now that we have discussed our threaded function and the structure used to pass through arguments, we need to look at the process of how we actually create our threads. You would have noticed earlier (just after the include declarative) that I defined a constant variable called NUM_THREADS. This is a constant variable, meaning it cannot change its value once it has been defined. Here, I am defining the number of threads I want to use in my script/code. In this example, I want to create two threads.

Inside the main function, you will see that I create a threads array, with a size provided from my constant variable NUM_THREADS. I then create a for loop to loop through the number of threads I want to create and begin creating my individual threads for the function threaded_function.

You can see in the body of the loop, that the first thing I do is create a structure called args which will store the arguments I am passing through to my threaded function. In this case, I am only passing through a single argument, which is a string declaring that Threading in 5062CEM is fun!.

After I have declared my arguments, I begin the process of creating my thread. This is achieved using the pthread_create function. The function accepts the following parameters:

thread: this is our unique identifier, and in this case it is the memory address of threads[i]
attr: these are attributes we may want to set for our thread, in this case nullptr is used, as we do not wish to pass through any attributes.
start_routine: this is the function we want to use for our thread, here we provide the function name threaded_function
arg: these are the arguments we want to pass through to our function. As we are passing through a structure with a character pointer, we need to type-cast our structure to void* as this is what is expected from the pthread_create function.

This process is repeated for the number of times I want my thread to be created. In this case, two threads will be created. You will see on the screen the output from our thread, and you will notice that two thread IDs have been used to indicate that two threads have been executed. If I were to increase our constant variable NUM_THREADS to four, then we can expect four threads to be created etc.

`pthread` Library (3)

Joining Threads

Joining multiple threads together is achieved with the pthread_join() function
Call the thread until the thread terminates

pthread_join(threadId, returnStatus);

Accepts two parameters:
- threadId: the ID of the thread to be joined
- returnStatus: a pointer to the location of the threads exit status

`pthread` Library (4)

Example: Joining Threads

The attribute state for joining needs to be declared
Threads can be joined together using the pthread_join()

#include <iostream>
#include <mutex>
#include <pthread.h>
#define NUM_THREADS 4
void* threaded_function(void* id) {
    static std::mutex lock;
    std::lock_guard guard{lock};
    std::cout << "Hello from Thread ID -> " << (long) id << std::endl;
    pthread_exit(nullptr);
}
int main() {
    pthread_t threads[NUM_THREADS];
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    for(int i = 0; i < NUM_THREADS; i++) {
        std::cout << "Creating Thread -> " << i << std::endl;
        int thread = pthread_create(&threads[i], &attr, threaded_function, (void*) i);
        pthread_join(thread, nullptr);
    }
    pthread_exit(nullptr);
    return 0;
}

Creating Thread -> 0
Creating Thread -> 1
Creating Thread -> 2
Creating Thread -> 3
Hello from Thread ID -> 1
Hello from Thread ID -> 3
Hello from Thread ID -> 2
Hello from Thread ID -> 0

This example is a little simpler compared to our previous one, and we shall not be using a structure to pass through our arguments. You will see that I have the same threaded_function from earlier, but with a few changes. Instead of printing the member from our structure, we are instead going to print the number that has been passed through.

Inside the main function, we create our threads array to the size that has been defined using the define declarative. In this example, I am looking at creating four threads. For the purpose of this example, I have also decided to provide some attributes to use in our pthread_create function. The attributes I have decided to use in this case is PTHREAD_CREATE_JOINABLE. This enables us to use the pthread_join function later on in our code.

We then create our for loop which will assist us in creating multiple threads quickly. Inside the body of our loop, I print the thread that is being created, i.e. 0, 1, 2 and 3 and then proceed with creating our thread using the pthread_create function. The key difference this time, is that I need to pass through our attr variable created earlier, to ensure we can join our threads. Once our thread has been created, I can then call the pthread_join function to join the threads together. Notice that at this time, our returnStatus has been provided the value nullptr as we are not concerned with listening for the exit status. Once our loop has finished iterating, we can then call the pthread_exit function to ensure our threads are terminated.

You will see from the output on the screen that the order in which our threads have finished executing is different compared to the order in which they have been created. This is due to the amount of time taken to execute each of the threads, and then terminated. In this case, thread had finished executing first.

`pthread` Library (5)

Detaching Threads

Detaching threads from each other is achieved with the pthread_detach() function

pthread_detach(threadId, returnStatus);

Accepts one parameter:
- thread: the unique ID of the thread to be joined

The last thing I want to discuss from the pthread library, is the detaching of threads. The function pthread_detach indicates that resources allocated to the thread may be recovered when a thread has been terminated. If a thread has not been created with a detached attributed, then the resources, such as the stack and thread ID, will not be recovered until a call to join them has been executed.

This means that the thread would do its work and terminate without signaling its parent thread. In our previous examples, we have seen that our parent thread must wait for a child thread to finish and join it. The parent thread is expected to combine the results of all the child threads to form the final output.

To create a detached thread, the pthread_detach function can be used, and it accepts a single parameter:

Threading in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Threading

Threading (1)

`thread` Library

`thread` Library (1)

Creating a Thread

`thread` Library (2)

Example: Creating and Terminating a Thread

`thread` Library (3)

`this_thread` Namespace

`thread` Library (4)

Killing a Thread

`pthread` Library

`pthread` Library (1)

Creating a Thread

`pthread` Library (2)

Example: Creating and Terminating a Thread

`pthread` Library (3)

Joining Threads

`pthread` Library (4)

Example: Joining Threads

`pthread` Library (5)

Detaching Threads

Goodbye

Goodbye (1)

Questions and Support

Threading in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Threading

Threading (1)

thread Library

thread Library (1)

Creating a Thread

thread Library (2)

Example: Creating and Terminating a Thread

thread Library (3)

this_thread Namespace

thread Library (4)

Killing a Thread

pthread Library

pthread Library (1)

Creating a Thread

pthread Library (2)

Example: Creating and Terminating a Thread

pthread Library (3)

Joining Threads

pthread Library (4)

Example: Joining Threads

pthread Library (5)

Detaching Threads

Goodbye

Goodbye (1)

Questions and Support

`thread` Library

`thread` Library (1)

`thread` Library (2)

`thread` Library (3)

`this_thread` Namespace

`thread` Library (4)

`pthread` Library

`pthread` Library (1)

`pthread` Library (2)

`pthread` Library (3)

`pthread` Library (4)

`pthread` Library (5)