DEV Community: Shreyos Ghosh

Behind the Scenes of C++ | Compiling and Linking

Shreyos Ghosh — Fri, 27 Oct 2023 13:49:30 +0000

C++ is a compiled language, which means that in order to run a program, one must convert it to machine-level language. While most of us use an IDE(Integrated Development Environment) which makes it for all intents and purposes, as easy as clicking a button. Which means most of the process is just abstracted away from us.

In this blog post, we'll deeply analyze the inner steps and processes which need to be done to convert our text-based code to machine-understandable form.

Grab your coffee...and write your helloworld.cpp program we're going to convert it to helloworld.exe soon...

Hello World of C++

Let's write our first C++ program. Open a text file in notepad or any text editor of your choice and simply paste or type the below C++ code. And save it as helloworld.cpp.



// This is our simple hello world program
#include <iostream>

int main(int argc, char* argv[]) {
    // this line below will print "Hello World!" to the screen
    std::cout << "Hello World!" << std::endl;
    std::cin.get();
    // if all goes well the main will return 0
    return 0;
}

Here, we will use a compiler provided by GNU called g++ to convert our C++ code to executable binary.

Note: C++ compilers doesn't have any way to tell whether you've written a C++ code or any other code in the file, other than to look on the file extension in this case .cpp. So, if you're writing a C++ source code you must save it using the extension .cpp or .c++, .cxx, .cp, .C. Now, for header files there is no such restrictions from the compiler itself. But, it is a best practice to name the header file with .h or .hpp extensions to maintain the code clarity and consistency.

Don't worry if you find the above code ambiguous, We'll talk more about the code in detail and also about headers(why we use headers and how actually it works) in my upcoming blogs.

Once you have your helloworld.cpp file, open the command prompt and navigate to the folder where you've saved your helloworld.cpp program. And run the command below to get the output file helloworld.exe.



g++ helloworld.cpp -o helloworld.exe

Note: If you're on Windows, to use the g++ compiler you must install the GNU toolchain port on Windows also known as MinGW-w64(Minimalist GNU for Windows) in your system.

By, now you should have the helloworld.exe file, upon clicking on it you'll have the "Hello World!" printed on your terminal window.

So, let's have a look on how the compiler converts our C++ code into machine executable form.

The C++ Compilation Model

To convert our C++ code into executable binary, the C++ compilers use the compilation model. It consists of a few essential stages that lay the foundation for successful code execution.

These stages consists of,

Preprocessing of the source code
Compiling the processed source code
Assembling the compiled file
Linking the object code binary

Let's talk about these stages into a bit more detailed way.

Preprocessing:

This is the first stage in the build process where the source codes undergoes a series of text formatting before the actual compilation begins. Which are,

Handling Preprocessor Directives: Preprocessor Directives or Preprocessor Statements are the commands that starts with the '#' symbol, and it instruct the preprocessor to perform certain textual manipulation on the source code. Which can be further categorized by,
- File Inclusion Directive - Embeds the contents of library headers and source headers to the source code. (Basically a simple copy and paste) Example: #include
- Macro Definition Directive - Replaces identifiers with replacement tokens or token-strings in the current file. Example: #define
- Conditional Directives - Conditionally compile sections of the current file. Example: #if, #endif, #ifdef, #ifndef, #else, #elif.
- Pragma Directives - Applies compiler-specific rules to specified sections of code. Example: #pragma once.
Removal of the Comments: Having the ability to write comments is a remarkable feature in C++. Making it more versatile and readable for us human readers.

Note: In, C++ we can write comments using two forward-slash "//Text-Comment"(Single-Line) or like this "/*Text-Comment*/"(Multi-Line).

However, the comments have no utility for the machine since the English language grammar is "far too loosely structured" to be used in the later stages. This is why during the preprocessing stage all the comments mentioned in the source file are replaced with one space character each and the newline characters are retained.

To, generate a preprocessed file helloworld.i from the helloworld.cpp source code, navigate to the source code directory again and run the below command,



g++ -E helloworld.cpp -o helloworld.i

Now, If you take a look at the generated preprocessed file, you'll see that, it is no longer our small helloworld program, rather it contains thousands of lines of code.

This is an indication that the preprocessor has done its job. It copied and pasted all the contents from the library header file iostream into the top of our helloworld.cpp file. And at the very end of the file content, you should see that all the comments are removed from our helloworld program.



# 3 "helloworld.cpp" 2


# 4 "helloworld.cpp"
int main(int argc, char* argv[]) {

    std::cout << "Hello World!" << std::endl;
    std::cin.get();

    return 0;
}

Compiling:

After the preprocessing of the source code is done, the individual intermediate source files are fed into the compiler as a separate translation unit where these files confront a series of phases to be transformed into assembler files.

These phases includes,

Lexical Analysis or Tokenization: In this phase, the source code lexemes(sequence of characters) are categorized into tokens. For example let's see how the compiler will tokenize the following line of preprocessed source code.



int main() {
    return 0;
}

Lexemes	Tokens
int	Keyword
main	Identifier
(	Left parenthesis(Operator)
)	Right parenthesis(Operator)
{	Left curly brace(Punctuator)
return	Keyword
0	Integer literal
;	Semicolon(Punctuator)
}	Right curly brace(Punctuator)

Note: Tokens are the smallest individual units of a program. C++ has different types of tokens, some of which are keyword(if, return, int), identifier(main, foo, var), literal(3.1415f, 0, "Hello World!"), Operator(=, +, -) and Punctuator((, ), {, }, ;).

Syntax Analysis or Parsing: During the syntax analysis the tokens are organized into a hierarchical structure known as a parse tree to check if the written code conforms to the language's syntax rules or not.



int main() {
    return 0
}

// The above code will generate error in the syntax analysis.

helloworld.cpp:5:13: error: expected ';' before '}' token
    5 |     return 0
      |             ^

Semantical Analysis: Semantical analysis focuses on checking the code's computational meaning and context. It converts the parse tree generated in the parsing phase, into a simpler abstract form without the unnecessary syntactical details such as braces, and commas, which is also known as Abstract Syntax Tree.

With the help of the AST, the parser verifies whether the variables are initialized before being used, whether types are compatible, and whether the code's behaviour aligns with the intended semantics of the language.



int var = "Hello";  // incompatible types 'var'(int) and "Hello"(const char*)
pi = 3.1415f;       // variable 'pi' not declared
int x;
int result = x + 3; // variable 'x' not initialized

Intermediate Code Generation: During this phase, the front end tree(AST), which we've obtained from the semantical analysis, is converted into an intermediate representation(IR), before it's sent to the optimizer for further analysis.

Note: One of the main reasons for this conversion is, essentially due to the fact that ASTs differ across different languages(C, C++). This means that performing the same type of optimization logic, on each language would require a different implementation. Which is not very ideal to maintain and upgrade.

g++ uses a three-address-based IR called GIMPLE(GNU SIMPLE representation) for high-level optimizations which is fully independent of the processor being targeted.

You can generate the GIMPLE file from the source file helloworld.cpp directly by using the following command.



g++ -fdump-tree-gimple=helloworld.gimple helloworld.cpp -o helloworld.exe

Code Optimization: This is the phase, also known as the middle end where most of the optimizations occur. These optimizations are mainly focused on the higher level, meaning that it won't be targeting the final hardware just yet.

Instead the optimization strategy is focused on various operations such as dead code elimination, removing redundant calculations, loop optimizations, constant folding, among others.



int foo(int x, int y) {
    int val = 10 + (5 * 3); //<= The value of this expression
                            //   will be replaced with one integer 
                            //   literal "25" during compile time 
                            //   vs. calculating it in runtime.
    int sum = x + y;
    return x + y; //<= Redundant code; This can be removed with
}                 //   the value of "sum" or the previous line can
                  //   be totally removed during the optimization 
                  //   phase.

Target Code Generation: Within this final phase the compiler converts the higher-level IR into a relatively lower-level format called RTL(Register Transfer Language). Which is very similar to assembly instructions but only contains pseudo-registers so that low-level optimizations can be easily performed on it.

The RTL is generated to adhere to the target architecture so that the real registers can be replaced with the pseudo registers later on in the register allocation phase. After the register allocation phase, the assembly instruction code is produced as an output string.

To generate the assembler source file use the following command,



g++ -S helloworld.cpp

Assembling:

In, the assembling stage the source assembler file that we have got from the last stage is sent to the assembler, where each of the source program statements are converted into a bit stream to construct the object code binary.

You can generate the object file helloworld.o from the helloworld.cpp file directly by running the command below,



g++ -c helloworld.cpp

The object code that we get out of this is not usable yet or executable to be exact. This is because we need to link the library code which holds the actual implementation for all the features that we have used in our helloworld program. This is where we need the linker.

Linking:

This is the final stage of the whole C++ compilation model, where the different object files generated from individual source files as a different translation unit get linked with the library files.

There are two ways to combine or link these two parts,

Static Linking: In, static linking, our separate .obj files and the static library .lib file are linked by the linker in the compile time(before the code gets executed in the memory) and produce a single portable executable binary.

Note: You might wonder why we need to link the .lib file when we've already included the iostream file. It is because the header files such as iostream only hold the features (i.e. declarations of variables, function signatures) that are available. However, the actual implementation of those functions can be found in a library file. And by combining those two parts we get a final executable file.

Dynamic Linking: Dynamic linking happens when our already compiled executable is linked with the runtime implementation of the library also called dynamically linked library file or .dll file.

Congrats! I hope you now have a good understanding of how the C++ compilation model and the linker function together to transform our C++ code into machine language.

Here, are some of the resource links that I read/watched while making this post. I highly encourage reading them if you're willing to learn more,

C++ Books That I have followed:

Programming: Principles and Practice Using C++ by Bjarne Stroustrup
C++ Fundamentals by Antonio Mallia and Francesco Zoffoli

About-

Compiling and Linking:

https://youtu.be/cpkDQaYttR4?si=DnV715eStRumC7fY

Preprocessor Directives:

Compiler:

GCC Internals:

Linker:

https://youtu.be/H4s55GgAg0I?si=4NkNvXkm4VHcGJ2k

Multithreading | Handling Race Conditions and Deadlocks in C++

Shreyos Ghosh — Fri, 17 Feb 2023 15:54:54 +0000

Previously, we've seen some different ways to create a thread instance and how to manage them using the join() and detach() methods.

In this article, I will discuss about move semantics of thread ownership, mutexes, and other related topics.

Move Ownership of a Thread:

In C++ <thread> by using std::move function we can move the ownership of an executable thread between different thread instances/objects.

As std::thread is a resource owning type, a thread of execution can only be moved across different instances but not copied to eliminate the chance of resource wastage.

Okay, enough talking! let's have a look at the example code,



1. void my_work();  //callable function
2. void my_other_work();
3. std::thread my_worker1(my_work);  //construction of thread 
   //object specifying the task
4. std::thread my_worker2;  //default constructed thread object
5. my_worker2 = std::move(my_worker1);  //moving ownership of the 
   //executable thread
6. my_worker1 = std::thread(my_other_work);  //construction of 
   //a new thread associated with temporary object

Code Example:



#include <iostream>
#include <thread>

int count = 0;
void my_work() {
    while (count++ < 2) {
        std::cout << "Doing my work!" << "\n";
    }
    std::cout << "My work is complete!" << "\n";
}
void my_other_work() {
    while (count++ < 2) {
        std::cout << "Doing my other work!" << "\n";
    }
    std::cout << "My other work is complete!" << "\n";
}

int main() {
    std::thread my_worker1(my_work);
    std::cout << "Thread Id of my_worker1 is " << my_worker1.get_id() << "\n";
    std::thread my_worker2;
    my_worker2 = std::move(my_worker1);
    my_worker1 = std::thread(my_other_work);
    std::cout << "Thread Id of my_worker1 is " << my_worker1.get_id() << "\n";
    std::cout << "Thread Id of my_worker2 is " << my_worker2.get_id() << "\n";
    my_worker1.join();
    my_worker2.join();
    return 0;
}

Code Output:



Thread Id of my_worker1 is 2
Thread Id of my_worker1 is 3
Thread Id of my_worker2 is 2
Doing my work!
My work is complete!
Doing my other work!
My other work is complete!

Explanation:

In our above code, at first in main function we created a new thread my_worker1 using the std::thread constructor, which is associated with the my_work function.

Next, we created a default constructed thread object my_worker2(i.e. it is not associated with any executable thread). In which we moved the my_worker1 thread object, using std::move function.

Doing this transfers the ownership of the underlying thread from my_worker1 to my_worker2, leaving my_worker1 in an invalid state.

After this, we have created a new thread that is associated with the std::thread temporary object and assigned it to the my_worker1 thread object.



my_worker1 = std::thread(my_other_work)

When we call std::thread by only specifying the task, the std::thread constructor creates a temporary object and assigns the ownership of the newly created thread to that object. Now, this thread doesn't start it's execution immediately. We can start it by providing a thread object to it.
That's why I've used the move assignment operator to assign the returned thread object by the std::thread constructor, to the thread object my_worker1. As you can see we don't need to call std::move for such assignment operations.

Here, I've used the get_id function to print the underlying thread ID to show that the ownership is actually getting transferred.

Now one thing to note, the thread ID may be different on your system, as it's determined by the OS and can vary from one run to the next. The value of the thread ID is not guaranteed to be unique(i.e. thread ID's can be recycled) or to have any particular meaning. It is simply a numerical identifier that is used to distinguish one thread from another within the same program.

For some reason, if you don't want to use std::move function, you can also use std::thread::swap to swap the ownership of the underlying threads.



1. thread_name.swap(other_thread_name);
or,
2. std::swap(thread_name, other_thread_name);

Now, I guess we should move to our next topic.

Race Condition and Data Race:

Suppose you're facing such a scenario, where you've more than one concurrent thread, trying to access and modify the same shared data concurrently and depending on the order in which they access the data the final outcome differs. Now, this can cause reliability issues in the program, this is what we call a Race Condition.

Data Races occur when two or more threads access a common memory location simultaneously and at least one of them modifies the data resulting in undefined corrupt data at that memory location.

It is possible that Race Conditions can occur because of Data Race or vice versa.

Let's see this with an example.

Code Example:



#include <iostream>
#include <thread>

int shared_counter = 0;

void increment_counter() {
    for (int i = 0; i < 100000; i++) {
    //--critical region--//
        shared_counter++;
    }
}

int main() {
    std::thread my_worker1(increment_counter);
    std::thread my_worker2(increment_counter);

    my_worker1.join();
    my_worker2.join();

    std::cout << "Final counter value: " << shared_counter << std::endl;
    return 0;
}

Before I explain the code, it's important to know that when we call the std::thread object specifying the task, the C++ threading API uses the lower level API (WinAPI for Windows) provided by the OS to launch a thread of execution.

In the process of which, the OS allocates the associated kernel resources and stack space and then it adds the new thread to the scheduler. After that, the thread scheduler executes those threads depending on it's various algorithms(FCFS, Time Slicing, Priority Based).

Different OS may use a different approach to schedule the threads. In case of Windows, it follows a priority-driven, preemptive scheduling system. Which means the threads scheduler can interrupt a running thread at any time and yield it's execution by putting it into a wait state to allow another thread with higher priority to execute.

Now that we have a bit of an idea about the underlying details let's get back to the code example.

Explanation:

So here, we have two concurrent threads my_worker1 and my_worker2 and both of them are working on the same shared_counter variable and doing increment operations for 100k times each. Cool!

It would be a fair guess if you think that the output will be 200k. But, after running the code quite a few times the outcome is nowhere near the expected result(At least for me). Now, why is it happening?

As I previously said, these two threads are running concurrently, so there is a chance that the progress made by one thread can be overridden by another thread because of the asynchronized interleaving instructions and the data race.

Here is the visualization of what might have happened.

Even though each thread has done the increment operation once but the final value stored in shared_counter is only 1, which is not the desired output.

Disclaimer: This visualization is only one of many scenarios that are possible, which means the order of these threads accessing the shared_counter variable can change. Now, run the for loop for 200k times and it ends up with complete chaos...

As Race Condition depends on the relative ordering of the instructions, most of the time it won't cause any issues(i.e. Benign Race Condition) as long as the invariants are not broken. But a problematic race condition may result in a broken invariant (final value ≠ expected value).

So, it is evident that we need some kind of synchronization for our threads. This is where Mutual Exclusion or Mutex come into play!

Thread Mutexes:

std::mutex class is a synchronization primitive that provides a locking mechanism which can be used to protect shared data from being simultaneously accessed by multiple threads.

Code Example:



#include <iostream>
#include <thread>
#include <mutex>

int shared_counter = 0;
std::mutex key;

void increment_counter() {
    for (int i = 0; i < 100000; i++) {
        key.lock();     // lock critical region
        shared_counter++;
        key.unlock();   // unlock critical region
    }
}

int main() {
    std::thread my_worker1(increment_counter);
    std::thread my_worker2(increment_counter);

    my_worker1.join();
    my_worker2.join();

    std::cout << "Final counter value: " << shared_counter << std::endl;
    return 0;
}

Explanation:

As you can see, we have created a std::mutex object called Key. By using the lock() and unlock() member functions of the std::mutex class, a thread (given that it reaches the mutex first) will be able to lock and unlock the shared_counter variable.

While the critical region is locked, other threads outside will be blocked until the critical region gets unlocked. Thereby the data race between these two threads will be avoided.

Blocking a thread in some cases may not be an optimal approach. To overcome that we can also use std::mutex::try_lock() rather than std::mutex::lock().



void increment_counter() {
    for (int i = 0; i < 100000; i++) {
        if(key.try_lock()) { // try to lock critical region
            shared_counter++;
            key.unlock();   // unlock critical region
        }
    }
}

What this would do is instead of putting the thread in a block queue, it returns the boolean value false, allowing the thread to try again later.

Here, goes the visualization of what may happen if we introduce try_lock() in our code.

“With greater flexibility comes greater responsibility.”

Although, try_lock() is solving a key issue here but it may introduce unexpected code behaviours. Also if not implemented properly it may lead to a livelock situation where two or more threads are constantly trying and failing to acquire the lock leading to wasted CPU cycles.

That's why the C++ std::thread library provides a special kind of mutex class called std::timed_mutex which comes with the std::timed_mutex::try_lock_for() and std::timed_mutex::try_lock_until() member functions.

Deadlock and Livelock:

A deadlock situation occurs when two or more blocked threads are waiting for each other to release a resource such as a mutex, which never gets released, resulting in the threads stopping their execution and waiting for an indefinite amount of time.

As bad as it sounds, deadlocks can easily hang our applications for an indefinite amount of time unless some external intervention occurs.

Let's try to recreate a deadlock situation,

Code Example:



#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

std::mutex cout_key;

void my_work() {
    cout_key.lock();
    std::cout << "Thread" << '[' << std::this_thread::get_id() << ']' << " acquired the lock" << '\n';
    //cout_key.unlock();
}

int main() {
    std::vector<std::thread> my_threads;
    for(int i=0; i<2; i++) {
        my_threads.emplace_back(my_work);
    }
    for(auto& i: my_threads) {
        i.join();
    }
    return 0;
}

One of the simplest kinds of deadlock can occur when a lock is acquired by a thread but never released.

In this example, the thread that locks the mutex first will print the output without releasing the lock, causing the other thread to be blocked upon attempting to acquire the lock and unable to proceed further.

A livelock situation, on the other hand, is similar to the deadlock situation but in this case, instead of the threads getting blocked, they constantly run on an active checking loop consuming CPU resources without making any real progress.

Code Example:



#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

std::mutex cout_key;

void my_work() {
    while(true) {
        if(cout_key.try_lock()) {
            std::cout << "Thread" << '[' << std::this_thread::get_id() << ']' << " acquired the lock\n";
            //cout_key.unlock();
            return;
        }
    }
}

int main() {
    std::vector<std::thread> my_threads;
    for(int i=0; i<2; i++) {
        my_threads.emplace_back(my_work);
    }
    for(auto& i: my_threads) {
        i.join();
    }
    return 0;
}

Similar to the previous scenario, the thread that acquires the cout_key mutex first will print the output without releasing it. As a result, the second thread will attempt to acquire the mutex and enter an infinite loop.

Whether it is a deadlock or a livelock, it is indeed one of the worst problems to face while developing any multithreaded applications.

To avoid situations like this, we can follow some guidelines, such as keeping the critical section short, following a specific order of mutexes, and putting a time bound on the waiting part.

We can also use some of the C++ features while working with locks, such as using RAII (i.e. scoped bound resource management) like std::lock_guard, or using std::scoped_lock to acquire more than one lock.

"Prevention is better than a cure"

In conclusion, threads can be a bit of a hassle to debug, and that's why it is important to follow the best practices from the very beginning so that at the end it doesn't become unmanageable and time-consuming to identify and fix bugs.

Multithreading | How to Create and Manage Threads in C++

Shreyos Ghosh — Wed, 23 Nov 2022 16:03:27 +0000

In any language, threads can be a very useful tool to do a certain task more efficiently by allowing the program to do multiple operations (e.g. input, processing, storage and output) at the same time. Threads can be utilized to allocate and execute different parts of a program without interrupting the main program.

Here, I will briefly talk about concurrency and parallelism as well as how you can implement multithreading in your C++ program.

What's a Thread?

A thread is a sequence of instructions that run in parallel to other threads within a process.

A process is a program which is under execution i.e. when a program is loaded into the memory then it becomes a process.

Now, that we know about threads, let's see the differences between concurrency and parallelism

Concurrency vs. Parallelism

Concurrency is closely related to multithreading, where more than one or many threads are handled at a period of time by switching the control from one thread to another back and forth. It may seem like all the threads are being executed at the same time. As this whole process is very quick but in reality, only one thread can be handled at a time. In concurrency, multiple threads can communicate with each other.

Parallelism is achieved when multiple threads are handled parallel to each other in hardware resources (multi-core, multi-chip or many cores).

Let's explain these two terms with a real-life example. Suppose there is one ticket counter managing two queues. Where only one person is getting a ticket at a time but that person can be from any queue. Here, if one queue is getting served then the other queue has to wait for it's turn and vice versa. This is an example of concurrency.

Now, if we increase the number of counters and make it two, then each queue gets it's own ticket counter and they can be managed in a parallel manner.

Here, as we can see each counter can only handle one customer or queue at a time. Similarly, consider these queues as a thread and counters as a core of a CPU with each core having the ability to handle only one thread at once, that's what we call a single-threaded core.

Now if you have two threads to run in a single-threaded core, then you need to run them in a concurrent manner(i.e. having two queues with only one counter).

But when you have more than one single-threaded core then you have the ability to run those two threads parallelly(i.e. having two queues with two counters/one counter each).

Concurrency --> Illusion
Parallelism --> True Concurrency

Nowadays, we can actually run two threads in one core at once (you can visualize them as a bigger core which is logically divided into two sub-core/smaller-core) which is also termed as hyperthreading.

For those who have confusion with the term "thread" being used by those CPU manufacturing companies vs. in software. What these companies mean by saying their CPU has "X" amount of threads, is actually how many threads that the CPU can run parallelly. But this doesn't mean that your CPU is limited to run only "X" amount of threads. Obviously, your CPU can run thousands of threads concurrently, but in that case, some threads will have to share hardware resources.

Managing Threads:

Up to this point, we've gained a little bit of understanding about multithreading. So let's have a look at how we can launch/create multiple threads in our C++ code.

Create a Thread:

There are three possible ways that we can create a thread. Which are,

Using Function Pointer
Using Function Object
Using Lambda Expression

Note: To work with threads, we will have to use the C++ standard library header <thread>. Every C++ program has at least one thread on which main() is called at program startup, it is called a main thread.

Using Function Pointer:

Here, we will pass a function pointer as a task for the thread object of std::thread class.



1. void my_task(parameters);  //callable function
2. std::thread my_worker(my_task, arguments);  //construction of
   //thread object specifying the task.

Code Example:



#include <iostream>
#include <thread>

void my_task(std::string name) {
    std::cout << "Hello world of " << name << "\n";
}
int main() {
    std::thread my_worker(my_task, "thread!");
    my_worker.join();
    return 0;
}

Explanation:

As I said, we are passing a function pointer my_task as a task to the thread object my_worker and as soon as the construction of the thread object is done, the thread starts the execution of the said task.

In total there are two threads present in the above program, one is the main thread and another one is the worker thread.

Notice, that here I've used thread join method join(), which we'll talk about later.

Using Function Object:

Function object which is also called as a functor, can be used to pass a callable object/instance of a class as a task to the thread object by overloading the function call operator () using operator function.

object + () = functor/function object



1. class my_functor {  //function object class
   public:
       void operator()(parameters) {  //operator function 
           //task list                //overloading () operator
       }
   };
2. my_functor Functor;  //declaration of object
3. std::thread my_worker(Functor, arguments);  //construction
   //of thread object using functor

Code Example:



#include <iostream>
#include <thread>

class my_functor {
public:
    //operator overloading
    void operator()(std::string name) {
        std::cout << "Hello it's me, " << name;
    }
};
int main(){
    my_functor Functor;
    std::thread my_worker(Functor, "Functor!");
    my_worker.join();
    return 0;
}

Explanation:

Here, we are passing a function object Functor() which belongs to the function object class my_functor as a task to the thread object my_worker, by overloading the function call operator/parenthesis operator ().

Using Lambda Expression:

A lambda Expression, which consists of a nameless function, can be passed as a task (i.e. a callable type) to the thread object.



1. auto my_lambda_exp = [capture clause](parameters) {
         //task list                    //lambda expression
   };
2. std::thread my_worker (my_lambda_exp, arguments);
   //construction of thread object using lambda expression

Code Example:



#include <iostream>
#include <thread>

auto my_lambda_exp = [](std::string name){
    std::cout << "Hello " << name;
};

int main() {
    std::thread my_worker (my_lambda_exp, "World!");
    my_worker.join();
    return 0;
}

Explanation:

Here, we are using a variable my_lambda_exp and passing it as a callable type for the thread object my_worker .
The lambda expression,
[](std::string name){std::cout << "Hello " << name;}
which is assigned to the variable my_lambda_exp, can also be used as a task for the thread object.

Code Snippet:



std::thread my_worker ([](std::string name){
    std::cout << "Hello " << name;
}, "World!");

For this case, you don't need to assign the lambda expression to a variable. You can put it directly and it will be treated as a callable type. Both of the given examples will work the same.

Now, it's time to talk about that join() method that we previously used.

Join and Detach a Thread:

When you launch a thread object, as said the thread will start the process of execution. At this point, you have the main thread and a worker thread running.

Now, you have two options either you can use join() i.e. pause the main thread and wait for the worker thread to complete the task and then continue the main thread execution or you can use detach() and continue the main thread execution and forget about the worker thread.

It is mandatory to either join or detach a thread before the main program execution is completed or it will be considered as an error and the std::terminate will be called by the thread destructor std::thread::~thread for garbage collection.

Joining a thread:

Let me give you a code example,



1. void my_work(parameters);  //callable function
2. std::thread my_worker(my_work, arguments);  //construction of
   //thread object passing the task
3. my_worker.join();  //joining the worker thread

Code Example:



#include <iostream>
#include <thread>

void my_work(int count) {
    while(count++ < 2){
        std::cout << "Worker thread is working..." << "\n";
    }
    std::cout << "The task is completed!" << "\n";
}
int main() {
    std::cout << "This is main thread!" << "\n";
    std::thread my_worker(my_work, 0);
    my_worker.join();
    std::cout << "Main thread execution completed!" << "\n";
    return 0;
}

Code Output:



 This is main thread!
 Worker thread is working...
 Worker thread is working...
 The task is completed!
 Main thread execution completed!

Explanation:

In the above program, after passing the function pointer my_work to the thread object my_worker, we've called the join() method and because of this, the main thread execution will be paused until the given task for the worker thread is done.

Before talking about the detach method, let's understand

What is `joinable()`?

std::thread::joinable is a method used to check if a thread has been joined/detached or not.

By default, every constructed thread object is joinable, Which means joinable() == true.

If not changed as usual this will trigger an error and the destructor std::thread::~thread will terminate the program by the end of the main program execution. Once a thread object is joined/detached joinable() == false.

Detaching a thread:

Let's say you're in such a scenario, where you don't want to pause the execution of the main program or the task for the worker thread is going to take a lot of time that you can't afford to wait on. That's when you can use detach() to run your thread in the background.

By using detach method we can execute the main thread and the worker thread (i.e. the caller thread and the called thread) independently from each other. And as soon as either one's execution ends, the thread destructor std::thread::~thread will be called and the resources will be released.



1. void my_work(parameters);  //callable function
2. std::thread my_worker(my_work, arguments);  //construction of
   //thread object passing the task
3. my_worker.detach();  //detaching the worker thread

Code Example:



#include <iostream>
#include <chrono>
#include <thread>
using namespace std::this_thread;
using namespace std::chrono;

void my_work(int count) {
    while(count++ < 2){
        std::cout << "Worker thread is working..." << "\n";
    }
    std::cout << "The task is completed!" << "\n";
}
int main() {
    std::cout << "This is main thread!" << "\n";
    std::thread my_worker(my_work, 0);
    my_worker.detach();
    std::cout << "Main thread execution completed!" << "\n";
    //sleep_until(system_clock::now() + seconds(2));
    return 0;
}

Code Output:



This is main thread!
Main thread execution completed!

Explanation:

If you run the given example code, you'll probably get an output like that.

So, let's talk about why this is happening...

I previously said that as soon as the construction of the thread object(of the worker thread) is done, the thread(worker thread) starts the execution of the said task.

Now there is a little more to be told! Let me explain...

When we construct a thread object and pass a callable type to it, first the OS collects the request and only then it initiates the execution. As it sounds this whole operation is not instantaneous.

Now when you're using the detach method, that means the underlying thread will be detached from the thread object and main thread won't be paused rather it'll continue to run until the flow of the program reaches the end. Which is much quicker in this case. That's why we are not getting the desired output from the worker thread.

But if you undo the commented line in the above code, which will let the worker thread to complete it's task by putting the main program into sleep for 2 seconds, then you'll get this output

Code Output:



This is main thread!
Main thread execution completed!
Worker thread is working...
Worker thread is working...
The task is completed!

Funfact: Threads might not be as evil as you thought!

DEV Community: Shreyos Ghosh

Behind the Scenes of C++ | Compiling and Linking

Hello World of C++

The C++ Compilation Model

Preprocessing:

Compiling:

Assembling:

Linking:

Multithreading | Handling Race Conditions and Deadlocks in C++

Move Ownership of a Thread:

Race Condition and Data Race:

Thread Mutexes:

Deadlock and Livelock:

Multithreading | How to Create and Manage Threads in C++

What's a Thread?

Concurrency vs. Parallelism

Managing Threads:

Create a Thread:

Using Function Pointer:

Using Function Object:

Using Lambda Expression:

Join and Detach a Thread:

Joining a thread:

What is joinable()?

Detaching a thread:

What is `joinable()`?