délégation d'appel de fonction à un thread

Version imprimable

22/03/2015, 12h16
Lintel-oo

délégation d'appel de fonction à un thread

Bonjour à tous,

je viens de me heurter à un problème dont les seules solutions que je vois sont absolument horribles au point de vue conception, c'est pour ça que je fais appel à votre aide ;).

Comme indiqué dans le titre, je cherche à exécuter des fonctions depuis un thread, en les lançant depuis le thread principal. J'explique la nécessité de faire cela : je code un petit wrapper pour coder en Opengl en utilisant le fenêtrage et les événements SDL, du coup vu que je veux qu'on puisse faire du multi fenêtrage et du multi vue dans chaque fenêtre, j'ai besoin de créer mes fenêtres dans l'unique thread graphique qui tourne. Sauf que je dois pouvoir créer des fenêtres depuis le thread principal. Du coup je dois appeler quelque chose du genre graphicalThread.addWindow(...); et graphicalThread ajoute la fenêtre dans sa boucle run. Cela implique de sauvegarder les arguments lors de l'appel à la fonction addWindow de graphicalThread.
C'est donc extrêmement laid, car je n'ai pas une seule fonction, mais une vingtaine, donc autant de "tuple" d'arguments à enregistrer.

Voyez-vous une solution propre ?

Edit : Evidemment, il faut que sitôt après avoir posté le message j'aie l'idée d'une solution qui me paraisse bien meilleure (je ne sais pas pourquoi écrire tuple m'a fait penser à ça), mais dites moi quand même ce que vous en pensez : lorsqu'on appelle addWindow, on ajoute une std::function f correspondant à la fonction qu'on souhaite appeler en lui bindant ses arguments, comme ça on n'a plus qu'à appeler f() dans l'update.

Hello,

Une simple std::deque<std::function<void()>> que tu remplis depuis n'importe quel thread, et que tu vide dans le thread principal doit faire l'affaire ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <thread>
#include <deque>
#include <mutex>
 
void addWindow(int, float) { }
void addWindow(double) { }
 
// second thread
void work(std::mutex& mut, std::deque<std::function<void()>>& tasks) {
	while(1) {
		// [...]
		{
			std::lock_guard<std::mutex> lock(mut);
 
			// quelques soit le nombre / type des arguments, c'est caché dans une lambda
			tasks.emplace_back([]() { addWindow(1, 0.4f); });
 
			// ou via std::bind, (cast pour choisir la bonne surcharge)
			tasks.emplace_back(std::bind(static_cast<void(*)(double)>(addWindow), 2.0));
		}
	}
}
 
int main() {
	// main thread
	std::mutex mut;
	std::deque<std::function<void()>> tasks;
 
	std::thread t([&mut, &tasks]() { work(mut, tasks); });
	while(1) {
		// [...]
		{
			// on récupère les traitements à effectuer par le thread principal
			std::lock_guard<std::mutex> lock(mut);
			while(!tasks.empty()) {
				tasks.front()();
				tasks.pop_front();
			}
		}
	}
	t.join();
	return 0;
}

En fonction de la durée des traitement, il est peut être préférable de ne pas garder le lock sur la deque pendant qu'ils sont effectués.

23/03/2015, 18h08
Lintel-oo

Ouep, c'est sur quoi je m'étais orienté (même si j'avais préféré utiliser une liste). Je pense que je peux passer le sujet en résolu vu qu'il ne doit pas exister de solution plus propre.