====== Création & Manipulation de Processus léger ======

[[in204:tds:sujets:td9|TD9]]

===== Références=====

[[http://en.cppreference.com/w/cpp/thread/thread|std::thread]]

===== Question n°1 =====

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

<code cpp>
#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;
}

</code>

Exécuter le code et analyser la sortie. Commenter celle-ci, notamment au regard de la documentation de la classe [[http://en.cppreference.com/w/cpp/thread/thread|std::thread]].

<hidden 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.

</hidden>


===== 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 :

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

et
<code cpp>
void main_process()
{
	for (int i = 1; i < 1000; i++)
	{
		std::cout << "Primary Thread: " << i << "\n";
	}
}
</code>
 
Tester le code.
 
<hidden 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''.

<code cpp>
int main()
{
	std::thread worker_proc(&worker_process, 10000);
	std::thread main_proc(&main_process);
	worker_proc.join();
	main_proc.join();
}
</code>

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:

<code cpp>
#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();
}
</code>

</hidden>