message loop et threads

Je voudrais mettre la boucle des messages dans un thread a part. Je precise tout de suite que je ne suis pas du tout un expert en threads

Je voudrais avoir un code comme ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

int main () { /* message loop */ while ((ret = GetMessage (&msg, NULL, 0, 0))) { /* translate and dispatch */ } /* creation de plusieurs fenetres */ w1 = CreateWindow (***); w2 = CreateWindow (***); ShowWindow (w1); ShowWindow (w2); /* main loop */ while (1) { *** } return 0; }

---

Evidement, la boucle des message bloque tout et je dois l'executer dans un autre thread. Notez que la main loop doit rester telle quelle. En particulier, je ne dois pas la placer dans un thread.

Donc, j'ai essaye ce code:

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

void message_loop (void *data) { MSG msg; while ((ret = GetMessage (&msg, NULL, 0, 0))) { /* translate and dispatch */ } } int main () { MSG msg; /* message loop */ _beginthread(message_loop, 0, NULL); /* creation de plusieurs fenetres */ w1 = CreateWindow (***); w2 = CreateWindow (***); ShowWindow (w1); ShowWindow (w2); /* main loop */ while (1) { *** } return 0; }

---

Le resultat est que mes fenetres sont bloquees vu qu'elles n'ont pas ete creees dans le meme thread de GetMessage (si j'ai bien compris la doc).

Que faut-il que je fasse pour creer mes fenetres dans le meme thread que GetMessage ?

merci

Ben, tu mets leur création dans ta fonction qui s'exécute dans l'autre thread...

Ou bien, tu peux essayer de jouer avec AttachThreadInput()... Ça peut marcher ou foirer, je ne sais pas exactement à quoi sert la fonction...

je ne peux pas tout mettre dans le thread. En fait je fais un wrapper des fonctions de Win32

donc j'ai un truc du style :

w1 = lib_create_window (***);

c'est l'utilisateur qui va creer le nombre d efeentre qu'il veut

Je vais voir en detail AttachThreadInput.

Merci

J'ai finalement decide que faire comme tu as dit (creer la fenetre et la boucle dans le meme thread sera le plus simple pour moi.

Reste un probleme : attendre la fin de l'initialisation de la fenetre avant de continuer le programme. Il faut que je fasse de la synchronisation de threads, mais je ne sais pas trop quoi exactement (event ? mutex ?).

En pseudo code, J'ai ceci:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void fct1() { instruction1; /* creation de la fenetre et d'autres trucs */ /* boucle messages */ while (1) { ** } } void fct2() { /* on execute fct1 dans un nouveau thread */ create_thread(fct1); instruction2; /* fin de l'initialisation de fct2 */ }

---

il faut donc que quand fct1 est execute, instruction1 soit executee avant instruction2.

Quelqu'un saurait-il ce que je dois utiliser, et comment ?

merci

Sous Win32, pour ce genre de choses, on utilise un Event.

On peut attendre la fin d'un thread avec la fonction WaitForSingleEvent(), et de plusieurs threads avec WaitForMultipleEvents(). On passe seulement à ces fonctions le ou les HANDLEs des threads à attendre, ainsi on a plus besoin de créer des Events.

:evilred: Vraiment n'importe quoi ... WaitForSingleObject() et WaitForMultipleObjects() et non Events, Events c'est à utiliser seulement avec les ... Events

ha je ne savais pas que l'on pouvais passer un handle de thread à la fonction :) !

En tout cas pour ce que tu cherche a faire, oui c'est ça qu'il faut utiliser.

@Melem: attention, je ne veux pas attendre la fin du thread : la fonction fct1 contient une boucle (a priori infinie). Si j'attend la fin du thread, je bloque tout mon programme au niveau de cette boucle.

Je veux juste attendre la fin de "instruction1", qui comporte la totalite de l'initialisation d'une fenetre pour ma lib. Puis je veux que mon programme continue normalement, c'est a dire avec "instruction2" (et la suite du programme).

Bon, faut que je matte la doc des events.

Merci

Bon, voici ce que je te propose :

Le programme principal :

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

int main() { HANDLE hThread; DWORD dwThreadID; if ((hThread = CreateThread(NULL, 0, ThreadFunc, NULL, 0, &dwThreadID)) != NULL) { /* Le thread a été créé avec succès ... */ /* ... on se concentre sur la console maintenant */ /* Et avant de quitter : */ PostThreadMessage(dwThreadID, WM_QUIT, 0, 0); WaitForSingleObject(hThread, INFINITE); CloseHandle(hThread); } else { /* Oups ca c'est mal passé */ } return 0; }

---

ThreadFunc :

Code:

---

1 2 3 4 5 6 7 8 9

DWORD WINAPI ThreadFunc(LPVOID lpParam) { /* On crée la fenêtre avec ou sans ta lib ... */ /* ... puis la boucle des messages */ return 0; }

---

Explication des lignes :

Code:

---

1 2 3 4

PostThreadMessage(dwThreadID, WM_QUIT, 0, 0); WaitForSingleObject(hThread, INFINITE); CloseHandle(hThread);

---

PostQuitMessage() retourne immédiatement sans attendre que le thread ait traité le message. Il faut quand même que le thread s'est terminé avant de vraiment quitter.