Un objet std::thread correspondant à un processus léger est créé et est associé au code la méthode simple_method. Ce processus démarre immédiatement et lance le calcul. L'exécution du code principal se poursuit et le message Main thread is executing and waiting est affiché. La ligne suivant attend que l'exécution du processus léger associé à l'objet std::thread termine. Une fois que ce processus a terminé, l'exécution du processus principal continue, affiche le message Alternate thread has terminated et rend la main.

Nous pouvons écrire le code suivant qui crée deux processus légers, le premier exécutant la fonction worker_process avec comme paramètre 10000 et le second exécutant la fonction main_proc.

int main()
{
	std::thread worker_proc(&worker_process, 10000);
	std::thread main_proc(&main_process);
	worker_proc.join();
	main_proc.join();
}

L'exécution commence par la tâche worker_proc et nous devons voir certains messages de la tâche main_proc, nous voyons cependant que les messages ne sont pas très entrelacés, ce qui est du au fait que l'on alloue un temps d'utilisation de la console à chacun des deux processus légers.

Pour mettre un peu d'entrelacement, nous pouvons ajouter un peu de temps entre les affichaches, par exemple 1ns pour le premier processus et 10ns pour le second. Ceci nous donne le code suivant:

#include<iostream>
#include<thread>
#include <chrono>
 
 
 
void worker_process(int numberOfIterations)
{
	for (int i = 1; i < numberOfIterations; i++)
	{
		std::cout << "Worker Thread: " << i << "\n";
		std::this_thread::sleep_for(10ns);
	}
}
 
void main_process()
{
	for (int i = 1; i < 1000; i++)
	{
		using namespace std;
		std::cout << "Primary Thread: " << i << "\n";
		std::this_thread::sleep_for(1ns);
	}
}
 
int main()
{
	std::thread worker_proc(&worker_process, 10000);
	std::thread main_proc(&main_process);
	worker_proc.join();
	main_proc.join();
}