Bonjour à tous,

Continuant mon apprentissage en développement, je souhaite savoir si il existe une "limite" de performances concernant les threads, ou, de manière plus générale, comment fonctionnent ces derniers ?
Je comprends le principe : paralléliser des processus (si tant est qu'ils soient parallélisables), mais finalement, comment ces threads sont traités par l' OS ? Car j'ai cru comprendre que c'est ce dernier qui gère les priorités des tâches concurrentes...

Dans le cas d'une fonction du style std::transform, y gagne t'on à paralléliser les opérations lorsque la fonction est "importante".
Par exemple, est-il intéressant de remplacer le code suivant :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
template<typename IT, typename OP>
void operate(IT first, IT last, IT outp, OP op) {
 
	while(first != last) {
		*outp = op(*first);
		++first;
		++outp;
	}
}
par

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
template<typename IT, typename OP>
void operate(IT first, IT last, IT outp, OP op) {
 
	std::vector<std::thread> thd;
 
	while(first != last) {
		thd.push_back(std::tread{op, outp, first});
	}
 
	for(auto & v:thd) {
		v.join();
	}
}
(En espérant que la syntaxe soit correcte)

En bref : comment se justifie l'utilisation des threads et quelles sont les limites de la parallélisation ?


Merci !