Table of Contents

Création & Manipulation de Processus léger

TD8

Références

std::thread

Question n°1

Créer un processus léger qui est associé à une fonction simple. 

#include<iostream>
#include<thread>
 
void simple_method()
{
	int i = 5;
	int x = 10;
	int result = i * x;
	std::cout << "This code calculated the value "
		<< result << " from thread ID: " 
		<< std::this_thread::get_id() << "\n";
}
 
 
int main()
{
	std::thread simpleThread(&simple_method);
	std::cout << "Main thread is executing and waiting\n";
	simpleThread.join();
	std::cout << "Alternate thread has terminated.\n";
	return 0;
}

Exécuter le code et analyser la sortie. Commenter celle-ci, notamment au regard de la documentation de la classe std::thread.

Correction

Correction

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.

Question n°2

Ecrire un programme qui lance les deux calculs suivants en parallèle, le premier dans un processus léger secondaire, le premier dans le processus léger principal : 

void worker_process(int numberOfIterations)
{
	for (int i = 1; i < numberOfIterations; i++)
	{
		std::cout << "Worker Thread: " <<  i << "\n";
	}
}

et 

void main_process()
{
	for (int i = 1; i < 1000; i++)
	{
		std::cout << "Primary Thread: " << i << "\n";
	}
}

Tester le code.  

Correction

Correction

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();
}