Attendre la fin des threads fils d'un processus

**SteelBox** · 22/02/2006, 15h36

Bonjour,
Dans un programme, je créer plusieurs threads et j'aurais besoin d'attendre la fin des threads que j'ai crées avant de terminer le processus. Y'a t-il une API pour cela ou faut il le faire soit même. Dans ce cas, il y a plusieurs solutions :
1. Stocker les handles des threads actifs dans une liste chainée
2. Faire un compteur avec sémaphore
3. Une variante du 2 : Déclencher une évènement quand le nombre de threads est à 0 (protection du compteur avec un mutex).

J'aimerais également pouvoir arrêter tous mes threads. J'ai juste à envoyer un évènement ? Faut il le retransmettre une fois qu'il a été "capté" par un thread afin que les autres threads puissent églament être avertis ?

J'attends vos avis

**Jean-Philippe Shields** · 22/02/2006, 17h24

Salut,

Je ne suis pas un pro du sujet, mais j'ai déjà personnellement utilisé une librairie open-source qui fait tout ce que tu demandes. Le framework open-source se nomme ACE et est développé par plusieurs universités :

http://www.cs.wustl.edu/~schmidt/ACE.html

Le framework inclus des patterns pour utiliser des objects concurrents et donne plusieurs outils de synchronisation, comme ce que tu mentionnes.

Pour répondre à ta question, personnellement j'utiliserais une variable conditionnelle (sémaphore) dans le thread principal pour attendre la fin de tous les threads lancés. Sur windows l'utilisation de waitForMultipleObjects() seraient approprié, selon mes connaissances.

**SteelBox** · 22/02/2006, 23h54

J'ai fait une petite classe perso avec un compteur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class GestionThreadsWin
&#123;
private&#58;
	HANDLE hMutex;
	int cpt;

public&#58;
	GestionThreadsWin&#40;&#41;;

	bool WriteCpt&#40;int nb&#41;;

	int ReadCpt&#40;&#41;;
&#125;;

Je suis quand même étonné. La librairie multitâche offerte par Windows me semble assez pauvre à côté de celles fournies par VxWorks ou Linux. Enfin les principes de bases sont là, donc on peut refaire ce qu'on veut...

**Médinoc** · 23/02/2006, 09h39

J'ai du mal à comprendre ce que tu veux.

Si tu veux que le process ne s'arrête quand TOUS ses threads sont terminés (au lieu du thread du main()/WinMain()), il suffit de remplaçer le return du main()/WinMain() par un appel à ExitThread() : Ainsi, seul ce thread se terminera, au lieu de terminer tout le processus.

Envoyé par http://msdn.microsoft.com/library/en-us/dllproc/base/terminating_a_process.asp

The primary thread can avoid terminating other threads by directing them to call ExitThread before causing the process to terminate (for more information, see Terminating a Thread). The primary thread can still call ExitProcess afterwards to ensure that all threads are terminated.

Si ce n'est pas ce que tu cherches, prière d'être plus explicite.

**SteelBox** · 23/02/2006, 11h53

Je ne sais pas si tu connais la fonction wait(0) sous unix/linux. C'est exactement ce que je veux : c'est à dire que je veux terminer mon processus après la mort de tous les processus fils (threads) qu'il a crée précédemment.

Si j'utilise l'exit thread, mon processus se termine. Hors je veux qu'il attende.

Est ce plus clair ?

**Aurelien.Regat-Barrel** · 23/02/2006, 11h59

Envoyé par SteelBox

Je ne sais pas si tu connais la fonction wait(0) sous unix/linux. C'est exactement ce que je veux : c'est à dire que je veux terminer mon processus après la mort de tous les processus fils (threads) qu'il a crée précédemment.

ton processus se termine tout seul quand son dernier thread meurt.

**SteelBox** · 23/02/2006, 14h04

ton processus se termine tout seul quand son dernier thread meurt.

J'ai testé et ce n'est pas ce qui se passe. Le processus exécute bien le exit et il n'attend pas la mort de ces threads.
Process Explorer de Sysinternals liste les threads d'un processus. J'aurais besoin de récupérer ces informations également. Savez vous comment faire ? y'a t-il une API ? il est possible que sysinternals ait été chercher eux même l'information en mémoire...

**Médinoc** · 24/02/2006, 00h07

1°) Tu peux nous montrer la fin de ton main() ou WinMain() ?
2°) On parle bien de threads ou de processus, là? Tu sembles mélanger les deux termes...

je veux terminer mon processus après la mort de tous les processus fils (threads)...

Edit: Citation à l'appui...

**SteelBox** · 24/02/2006, 11h41

Je ne pense pas mélanger les termes. Relis bien ce que j'ai écrit et dis moi ou tu penses que je mélange.
Thread=processus léger. Il possède une desciption réduite et appartient à un processus ce qui fait que le changement de contexte est plus rapide avec un thread.

Et je n'ai pas de main, c'est une dll.

En gros, voici ce que je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
				threadID=CreateThread&#40;	NULL	,	// Attributs de sécurité &#40;par défaut&#41;
					0								,	// Taille de la pile &#40;par défaut&#41;
					&#40;LPTHREAD_START_ROUTINE&#41;&ExecuteThread	,	// Adresse de la threadproc
					&#40;LPVOID&#41;this						,	// Paramètres &#40;pointeur this&#41;
					0								,	// Flag de création &#40;0 ou CREATE_SUSPENDED&#41;
					0								&#41;;	// Pointeur vers le ThreadID &#40;aucun&#41;

...

sysGtw.WriteCpt&#40;1&#41;;

A la destruction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sysGtw.WriteCpt&#40;-1&#41;;

Mon WriteCpt émet un évènement pour me prévenir quand tous les threads que j'ai crées sont morts :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
44
45
46
bool GestionThreadsWin&#58;&#58;WriteCpt&#40;int nb&#41;
&#123; 
    DWORD dwWaitResult;

    // Request ownership of mutex.
 
    dwWaitResult = WaitForSingleObject&#40; 
        hMutex,   // handle to mutex
        5000L&#41;;   // five-second time-out interval
 
    switch &#40;dwWaitResult&#41; 
    &#123;
        // The thread got mutex ownership.
        case WAIT_OBJECT_0&#58; 
            __try &#123; 
                // Writing and testing
					cpt+=nb;

					if&#40;cpt==0&#41;
					&#123;
						SetEvent&#40;hStopEvent&#41;; // there is no running threads
					&#125;

            &#125;
            __finally &#123; 
                // Release ownership of the mutex object.
                if &#40;! ReleaseMutex&#40;hMutex&#41;&#41; 
                &#123; 
                    // Deal with error.
                &#125; 

                break; 
            &#125; 

        // Cannot get mutex ownership due to time-out.
        case WAIT_TIMEOUT&#58; 
            return false; 

        // Got ownership of the abandoned mutex object.
        case WAIT_ABANDONED&#58; 
            return false; 
    &#125;

    return true;
&#125;

**Aurelien.Regat-Barrel** · 24/02/2006, 13h25

Si c'est toi qui crée les thread, dans le thread principal, pourquoi n'en gardes-tu pas trace ?
Un WaitForMultipleObjects sur les handle des threads créés avec bWaitAll = TRUE fera l'affaire ensuite.

**Aurelien.Regat-Barrel** · 24/02/2006, 13h30

Envoyé par SteelBox

ton processus se termine tout seul quand son dernier thread meurt.

J'ai testé et ce n'est pas ce qui se passe.

je viens de tester sous XP:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <windows.h>

DWORD WINAPI ThreadProc&#40; LPVOID  &#41;
&#123;
    Sleep&#40; 3000 &#41;;
    MessageBox&#40; 0, TEXT&#40; "Ca va couper!" &#41;, TEXT&#40; "" &#41;, 0 &#41;;
    return 0;
&#125;

int main&#40;&#41;
&#123;
    CloseHandle&#40;
        CreateThread&#40; NULL, 0, ThreadProc, 0, 0, NULL &#41; &#41;;
    ExitThread&#40; 0 &#41;;
&#125;

j'ai bien le messagebox qui s'affiche.

**SteelBox** · 24/02/2006, 13h34

Oui, j'avais pensé à cette solution, mais je pensais que Windows devait justement garder cette trace (enfin il l'a garde surement mais il n'offre pas la possibilité d'y avoir accès avec une API). Sinon, je pensais faire une liste chainée des threads mais pour l'instant, le fait de les compter me suffit. Si j'ai besoin de les stopper ou les mettre en pause, j'adopterai la solution de la liste chainée.

Bref, je pensais que l'API Windows était plus fournie que ca. Vous avourez qu'il s'avère étonnant qu'aucune API ne permette d'attendre la fin des threads crées par notre processus.

Merci pour votre aide, j'ai eu les réponses que j'attendaient

**Aurelien.Regat-Barrel** · 24/02/2006, 13h47

Envoyé par SteelBox

Bref, je pensais que l'API Windows était plus fournie que ca. Vous avourez qu'il s'avère étonnant qu'aucune API ne permette d'attendre la fin des threads crées par notre processus.

Mais ça n'a pas de sens. Si dans ton thread principal tu attends que tous les thread du processus soient terminés, vu que le thread principal est avant tout un thread du processus comme un autre, il va attendre sa propre fin, autrement dit, il va attendre indéfiniment.
Après on peut lister les thread d'un process en Win32, mais vu que c'est ton propre process, ça semble plus normal et surtout c'est plus simple de garder une trace de ce que tu crées.

**SteelBox** · 24/02/2006, 14h44

C'est vrai que la fonction wait de Linux mentionne les "processus fils". Il y a donc une petite distinction avec Windows. Néamoins cette fonction est réelement très utile :
http://www.die.net/doc/linux/man/man2/wait.2.html

-1 which means to wait for any child process;

Concernant le CloseHandle, ca semble marcher effectivement (ce n'est pourtant pas vraiment explicité dans la MSDN). Merci

Closing a thread handle does not terminate the associated thread. To remove a thread object, you must terminate the thread, then close all handles to the thread.

Tout est question de choix. Windows aurait pu fournir ce que je demande. Comme je l'ai déjà dit, ce n'est pas vraiment génant puisqu'on peut le refaire soi-même. Bref, le sujet est clos

**Aurelien.Regat-Barrel** · 24/02/2006, 15h47

Dans mon code le CloseHandle n'y est pour rien, c'est juste que tu dois libérer le HANDLE qu'on te renvoie.
Version plus courte:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <windows.h> 

DWORD WINAPI ThreadProc&#40; LPVOID  &#41; 
&#123; 
    Sleep&#40; 3000 &#41;; 
    MessageBox&#40; 0, TEXT&#40; "Ca va couper!" &#41;, TEXT&#40; "" &#41;, 0 &#41;; 
    return 0; 
&#125; 

int main&#40;&#41; 
&#123; 
    CreateThread&#40; NULL, 0, ThreadProc, 0, 0, NULL &#41;; 
    ExitThread&#40; 0 &#41;; 
&#125;

le thread principal lance un 2° thread et se termine. Pourtant le processus continue de tourner, car tous les threads ne sont pas terminés. Quans le 2° thread se termine, le process se termine aussi, automatiquement.

C'est vrai que la fonction wait de Linux mentionne les "processus fils". Il y a donc une petite distinction avec Windows. Néamoins cette fonction est réelement très utile :

c'est même un grosse différence. Et dans le contexte Win32, on utilise très peu les processus fils, contrairement à UNIX où on fork à tous va. En Win32 on utilise les threads. La notion de processus père n'est pas aussi forte sous Windows.

**SteelBox** · 24/02/2006, 16h08

Et pourtant il y a une librairie pthread sous Linux

Merci pour tes indications. Je sais comment faire maintenant

Attendre la fin des threads fils d'un processus

Windows

Discussions similaires

Partager

Partager