DEV Community: Hoàng Văn Khoa

Introduction to multithreading in C/C++

Hoàng Văn Khoa — Mon, 26 Sep 2022 10:24:25 +0000

This is the first in a series of blog posts about multithreading in C/C++. The series contains not only my notes but also some bits of advice I made to myself. If you find them helpful, that is so great. If you find incorrect information, please let me know.
I assumed you have some basic understanding of the thread of execution in general and some experience in C/C++ programming.

Hello Multithreading World

The Modern C++ Standards (C++11 and later) bring many exciting features into the C++ language and standard library that make coding in C++ easier, more productive, and more secure. One of those features is the C++ Standard Library's built-in support for multithreading. Before C++11, developers have to write C-style code using platform-specific C APIs to enable multithreading in their code.

Mentioning multithread C APIs, there are supports for multithreading in C. But they are not a part of the C Standard Library. I can name two here: Win32 API and POSIX.

While Win32 API is Windows-specific, POSIX is an industry standard that many systems implement. For example, macOS is a POSIX-certified system. Linux, however, isn't a POSIX-certified system. But it can be qualified as mostly POSIX-compliant. In automotive, a standard that requires its implementations must comply with POSIX is the AutoSAR Adaptive Platform.

Currently, as an automotive software engineer, I have two options to enable multithreading in my code:

C code and POSIX Threads (commonly known as Pthreads)
C++ code and C++ Thread

I can always write C-style code in C++ programs, but I will avoid that style of programming as much as possible. Mixing C-style code in a C++ program makes the code harder to understand and debug.

The next sections will show an overview of multithreading in the two standards.

Pthreads

The support for multithreading of a POSIX system consists of 3 components:

The header file pthread.h is the declaration of the API.
The implementation of the API.
A C compiler and linker.

For example, macOS is a POSIX-certified system. The implementation for Pthread is lib_pthread. The macOS SDK, which developers can download for free, provides the header file pthread.h and clang, the compiler and linker. I'd recommend downloading Xcode, which has the SDK included.

Another example that can be mentioned is Linux, a mostly POSIX-compliant system. The implementation is the Native POSIX Threads Library (NPTL), which is a part of The GNU C Library (glibc). By obtaining GCC, you have an implementation, the header file, the compiler and the linker. Most Linux distros have the package gcc. Follow your package manager manual to install it. For example:

On Ubuntu, run sudo apt-get install gcc
On Fedora, run sudo dnf install -y gcc

Grab the tools you need for your system, and take a look a the following hello world example:

In which:

helloWorld(): The function which shall be executed in the new thread.
pthread_t: Thread identifier type, needed by most Pthreads APIs.
pthread_create(): Creates and launches a new thread of execution. It also gives us an identifier and then returns an exit code.
pthread_join(): The calling thread waits for the thread (specified by an identifier) to terminate.

To compile the example, you can use either clang or gcc. You may want to use the system default C Compiler by using the cc command line utility:

As you may notice, I use some compiler options:

-Wall -Wextra: The compiler produces more warnings about potential defects.
-Werror: The compiler treats all warnings as errors.

The combination of these options prevents you from making mistakes in the early stage. You may find them annoying sometimes. But paying attention to the warnings, thinking about their meaning, and thinking of how to avoid them will make you a better programmer.

You may also notice that I don't ignore the exit codes that pthread_create() and pthread_join() return. In the example, the compiled program will return 0 if the execution is successful, or an error code that POSIX defines in errno.h. Experience users can look up the error code in errno.h and find out what was wrong. That's very basic error handling. Remember, don't skip error handling. The more time you spend on writing error handling code, the less time you will have to spend on defect investigation. Defects on multithreaded code are very hard to find, so keep that in mind.

That's the hello world of Pthreads. Next, I will introduce the C++ Thread.

C++ Thread

Unlike the C Standard, modern C++ Standards (since C++11) specify built-in supports for multithreading in the C++ Standard Library. These supports include the classes for managing threads, protecting shared data, synchronizing between threads, and low-level atomic operations, which makes coding multithread easier and safer. I think the best part is now you can have a consistent C++ programming experience while working with threads, regardless of the runtime system.

Note that the C++ Standard is a technical specification. The actual implementation is done by compiler vendors, like GCC, LLVM, Microsoft C++, etc. On a POSIX system, C++ Thread is implemented using Pthreads. In this case, C++ Thread is a wrapper that wraps underlying POSIX APIs. This action comes with a cost, called the abstraction penalty. In most cases, developers are happy to pay this cost. But if the utmost in performance is what you're after, then consider writing your code in C, with the only support for multithreading being either platform-specific or Pthreads. Other than that, if you're programming in C++, I'd recommend C++ Thread.

You can start writing the hello world example with a C++ compiler that supports C++11 or later:

In which:

The class std::thread is declared in the header file thread.
The function which will be executed in the new thread is defined in the class BackgroundTask.
The new thread will be created and launched by the constructor of std::thread.
The std::thread::join() member function causes the calling thread waits for myThread to terminate.
Instead of C-style error code handling, C++ provides exception handling mechanism.

Both the constructor and the member function join() of the class std::thread can throw std::system_error exception. Although C++ compilers don't require catching every thrown exception, I think it's a good practice that you understand every exception a function can throw, and handle them properly. In the example, I just print out the information about the exception that std::system_error::what() provides, and returns -1, indicating a failure.

To compile the example, refer to the following command line for your compiler (g++ or clang++):

The meaning of the compiler options is the same as gcc and clang.

So, that's hello world to Pthreads and C++ Thread. In the next post, I will introduce to you how to launch a thread, using Pthreads and C++ Thread.

Launching a thread in C/C++

Hoàng Văn Khoa — Fri, 23 Sep 2022 10:47:37 +0000

Note: Since I decided to write a series about multithreading in C/C++, I’m going to rewrite this article.

Introduction

Talking about multithreading in C/C++, there are two standards that specify the APIs for multithreading:

POSIX Threads: commonly known as Pthreads, is a part of the POSIX Standard.
ISO C++ (since C++11): yes, C++ now has built-in support for multithreading, I'm going to call it C++ Thread for short.

In C, you can use Pthreads. In C++, you have a choice between Pthreads and C++ Thread. The implementations for the two standards can be found on most major systems, from PC (macOS, FreeBSD, Linux, ...) to automotive (AutoSAR Adaptive Platform, ...). If you're an Android platform developer and working on AOSP, you might have been working with them already. If your system doesn't support Pthreads, you have an option to use platform-specific thread APIs in C, or you can write in C++ and do multithreading using C++ Thread.

In this post, I'm going to show you some basic examples of both standards to create and launch a new thread. I also remind you to handle the error which might happen. I assumed that you already know how to compile these examples. If you don't, leave a comment.

Launching a thread using Pthreads

We call the function pthread_create to create a new POSIX thread and launch it. The declaration of the function is:

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

By presenting it this way, I mean that pthread_create is declared in the header file pthread.h and it needs 4 parameters to create a new thread:

pthread_t *thread is the pointer to the thread identifier which we are about to receive, so it cannot be NULL.
const pthread_attr_t *attr is the attribute object. If it's NULL, the default attributes are used. The newly created thread will have these attributes set by pthread_create.
void *(*start_routine)(void *) is the function to be executed in the new thread, so it cannot be NULL.
void *arg allows us to pass an argument to the start_routine function. Because its type is declared as void *, you can pass any value which has the same size as size_t, or a pointer to any type of object. If arg is a pointer, you must make sure the data that arg points to remains valid during the execution of the start_routine function.

pthread_create returns 0 if it successfully created a new thread. Otherwise, an error number will be returned to indicate the error. These numbers are defined in errno.h. The error numbers that pthread_create can return are:

EAGAIN: The system lacked the necessary resources to create a new thread, or the process reaches its quota (PTHREAD_THREADS_MAX).
EPERM: The caller does not have permission to set the required scheduling parameters or scheduling policy.
EINVAL: Invalid attribute(s).

It's bad practice if you don't check and handle the error number that pthread_create returns. But for the sake of complexity, in the following example, I'd leave the error handling for the caller of the launchMyThread() function:

#include <pthread.h>
#include <stdio.h>

pthread_t myThread;
/**
 * `myThread`'s routine
 */
void *doSomething(void *arg) {
  (void)(arg); /* To avoid a compiler warning that said argument `arg` is unused */
  printf("[%s:%d %s]\n", __FILE__, __LINE__, __FUNCTION__);
  /* In this example, `doSomething` just returns `0` to indicate a successful execution */
  return (void *)0;
}

/**
 * Launch myThread
 * @return 0        : success
 *         non-zero : failure, see errno.h
 */
int launchMyThread() {
  /* `myThread`'s initial attributes */
  pthread_attr_t attr;
  int exitCode = 0;

  pthread_attr_init(&attr);
  /* one of `myThread`'s attributes will be joinable, meaning the calling thread must wait for it to return */
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  exitCode = pthread_create(&myThread, &attr, &doSomething, NULL);
  /* the caller must handle the error */
  return exitCode;
}

There are two Pthreads functions that I have yet to mention: pthread_attr_init(), pthread_attr_setdetachstate. They will be covered in an upcoming post.
Now, move on to the next section to see how to achieve the same using C++ Thread.

Launching a thread using C++ Thread

C++ provides the std::thread class (defined in <thread>) to manage the thread of execution. To create a thread, we construct an object of the std::thread class. The constructors look like this:

thread() noexcept; // Default constructor
template<typename Callable,typename Args...>
explicit thread(Callable&& func, Args&&... args); // Second constructor
thread(thread const& other) = delete; // No copy constructor
thread(thread&& other) noexcept; // Move constructor

The first constructor constructs an object, but it's not associated with any thread of execution. It is there for constructing an object without anything to execute.
The second one constructs an object that's associated with a thread of execution because it has enough information to do so:

Callable&& func: an callable object.
Args&&... args: some arguments. They're optional. You may pass no argument. func and each element of args must be MoveConstructible.

Note

A MoveConstructible (since C++11) object is a object that can be constructed from a rvalue argument.

The && operator, in this case, is the rvalue reference declarator.

But what exactly are they? What do they do here? Well, I will cover this in another post called Move Semantics in C++.

Let's take a look at the following example:

#include <iostream>
#include <system_error>
#include <thread>

class BackgroundTask {
public:
  void doSomething();
  void doAnotherThing();
  void operator()() const {
    doSomething();
    doAnotherThing();
  }
};

int launchMyThread() {
  try {
    BackgroundTask task;
    // `task` is copied into `myThread`'s storage, so make sure the copy behaves
    // equivalently to the original
    std::thread myThread(task);
  } catch (std::system_error error) {
    std::cout << error.what() << std::endl;
    return -1;
  }

  return 0;
}

This is not the simplest example of launching a thread using C++ Thread. But it sure shows some differences between C-style code and C++ style. First, it constructs a BackgroundTask object, which is callable because the class overrides the function call operator (). Of course, you can also pass a function, or a lambda expression, anything that is callable. The callable object is copied into the storage belonging to the newly created thread of execution and invoked from there. Therefore, you need to ensure that the copy behaves equivalently to the original, or the result may not be what you expect.

The example also shows that is optional to pass arguments. But if you need to, you can pass more than one argument, unlike pthread_create, which only allows you to pass only one argument. To receive arguments, the class BackgroundTask needs to override the function call operator with parameter(s):

#include <iostream>
#include <string>
#include <system_error>
#include <thread>

class BackgroundTask {
public:
  void operator()(std::string_view name) const {
    std::cout << "Hello " << name << std::endl;
  }
};

int launchMyThread() {
  try {
    BackgroundTask task;
    std::thread myThread(task, "Multithreading World");
  } catch (std::system_error error) {
    std::cout << error.what() << std::endl;
    return -1;
  }

  return 0;
}

It's also bad practice if you don't do the error handling, in this case, exception handling. The second constructor throws a std::system_error exception if it's unable to start the new thread, or if there's an exception while copying func or args into local storage.

📝 Never forget to handle errors or exceptions. Spend more time writing error/exception handling and you will spend less time investigating bugs.

So that's how you create and launch a new thread of execution, using Pthreads/C++ Thread. There's more about multithreading in C/C++. Stay tuned for updates!