[ WaitForMultipleObjects ] Lister tous les objets signales ?

**M4tthieu** · 03/07/2007, 18h17

Bonjour tout le monde

J'utilise la methode WaitForMultipleObjects(). Le soucis est que cette fonction retourne seulement le premier handle signale.

Ce que je cherche a savoir, c'est si il est possible de lister tous les handles signales, et non pas seulement le premier ?

**M4tthieu** · 04/07/2007, 09h17

Personne ? :s

**Damess** · 04/07/2007, 09h43

Bonjour.

Et pourquoi ne pas mettre une bloucle qui empile les "HANDLE"s dans une liste ?

**r0d** · 04/07/2007, 10h26

Bonjour,

je ne comprends pas trop le sens de ta question. Car quand tu sors d'un WaitForMultipleObjects, soit TOUS les threads sont finis (dans le cas du bWaitAll (3eme paramètre de WaitForMultipleObjects) est à TRUE), soit seul un thread est fini (bWaitAll) et tu sais lequel.

Cela dit, jette un coup d'oeil sur le code suivant, peut-être que ça pourra aider:

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include "windows.h"
 
#include <iostream>
 
using namespace std;
 
#define NB_THREADS 4
 
struct ThreadsMarker
{
	ThreadsMarker()
	{
		finishedThreads = new bool[4];
		for(int i=0; i<NB_THREADS; i++)
			finishedThreads[i] = false;
	}
	~ThreadsMarker(){delete [] finishedThreads;}
	bool* finishedThreads;
} ;
 
 
DWORD WINAPI func0( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func0" << endl;
		Sleep(500);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[0] = true;
	cout << "func0 finished" << endl;
	return 0;
}
 
DWORD WINAPI func1( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func1" << endl;
		Sleep(480);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[1] = true;
	cout << "func1 finished" << endl;
	return 0;
}
 
DWORD WINAPI func2( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func2" << endl;
		Sleep(850);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[2] = true;
	cout << "func2 finished" << endl;
	return 0;
}
 
DWORD WINAPI func3( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func3" << endl;
		Sleep(670);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[3] = true;
	cout << "func3 finished" << endl;
	return 0;
}
 
 
int main(int argc, char* argv[])
{
	HANDLE handles[NB_THREADS];
	DWORD dwThreadId[NB_THREADS];
	DWORD dwEvent;
	ThreadsMarker tm;
 
	handles[0] = CreateThread( NULL, 0, func0, &tm, 0, &dwThreadId[0]);
	handles[1] = CreateThread( NULL, 0, func1, &tm, 0, &dwThreadId[1]);
	handles[2] = CreateThread( NULL, 0, func2, &tm, 0, &dwThreadId[2]);
	handles[3] = CreateThread( NULL, 0, func3, &tm, 0, &dwThreadId[3]);
 
	dwEvent = WaitForMultipleObjects(NB_THREADS, handles, FALSE, INFINITE);
 
	cout << dwEvent << endl;
	cin.get();
	return 0;
}

Hope it helps.

**Laurent Gomila** · 04/07/2007, 10h45

je ne comprends pas trop le sens de ta question. Car quand tu sors d'un WaitForMultipleObjects, soit TOUS les threads sont finis (dans le cas du bWaitAll (3eme paramètre de WaitForMultipleObjects) est à TRUE), soit seul un thread est fini (bWaitAll) et tu sais lequel.

Pas forcément non. La doc indique clairement que si plusieurs objets sont prêts, seul celui qui a le plus petit handle sera renvoyé.

Cela dit, jette un coup d'oeil sur le code suivant, peut-être que ça pourra aider:

On ne sait même pas s'il s'agit de threads

Il faudrait fouiller dans la MSDN pour voir s'il n'y aurait pas des variantes plus appropriées, mais sinon une bidouille simple pourrait être, après le premier appel, de boucler jusqu'à ce que la fonction ne renvoie rien, avec un temps d'attente nul et en retirant le dernier handle renvoyé du tableau à chaque itération.

**M4tthieu** · 04/07/2007, 12h42

Envoyé par r0d

Bonjour,

je ne comprends pas trop le sens de ta question. Car quand tu sors d'un WaitForMultipleObjects, soit TOUS les threads sont finis (dans le cas du bWaitAll (3eme paramètre de WaitForMultipleObjects) est à TRUE), soit seul un thread est fini (bWaitAll) et tu sais lequel.

Cela dit, jette un coup d'oeil sur le code suivant, peut-être que ça pourra aider:

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include "windows.h"
 
#include <iostream>
 
using namespace std;
 
#define NB_THREADS 4
 
struct ThreadsMarker
{
	ThreadsMarker()
	{
		finishedThreads = new bool[4];
		for(int i=0; i<NB_THREADS; i++)
			finishedThreads[i] = false;
	}
	~ThreadsMarker(){delete [] finishedThreads;}
	bool* finishedThreads;
} ;
 
 
DWORD WINAPI func0( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func0" << endl;
		Sleep(500);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[0] = true;
	cout << "func0 finished" << endl;
	return 0;
}
 
DWORD WINAPI func1( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func1" << endl;
		Sleep(480);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[1] = true;
	cout << "func1 finished" << endl;
	return 0;
}
 
DWORD WINAPI func2( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func2" << endl;
		Sleep(850);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[2] = true;
	cout << "func2 finished" << endl;
	return 0;
}
 
DWORD WINAPI func3( LPVOID lpParam ) 
{
	for (int i=0; i<5; i++)
	{
		cout << "func3" << endl;
		Sleep(670);
	}
	ThreadsMarker* tm = reinterpret_cast<ThreadsMarker*>(lpParam);
	tm->finishedThreads[3] = true;
	cout << "func3 finished" << endl;
	return 0;
}
 
 
int main(int argc, char* argv[])
{
	HANDLE handles[NB_THREADS];
	DWORD dwThreadId[NB_THREADS];
	DWORD dwEvent;
	ThreadsMarker tm;
 
	handles[0] = CreateThread( NULL, 0, func0, &tm, 0, &dwThreadId[0]);
	handles[1] = CreateThread( NULL, 0, func1, &tm, 0, &dwThreadId[1]);
	handles[2] = CreateThread( NULL, 0, func2, &tm, 0, &dwThreadId[2]);
	handles[3] = CreateThread( NULL, 0, func3, &tm, 0, &dwThreadId[3]);
 
	dwEvent = WaitForMultipleObjects(NB_THREADS, handles, FALSE, INFINITE);
 
	cout << dwEvent << endl;
	cin.get();
	return 0;
}

Hope it helps.

J'ai lu, mais j'ai trouve une solution, j'utilise waitForSingleObject, ainsi je peux tracer chaque handle cree. C'est un peu lourd mais ca marche

Merci a vous deux d'avoir aide

**M4tthieu** · 04/07/2007, 12h44

Envoyé par Laurent Gomila

Pas forcément non. La doc indique clairement que si plusieurs objets sont prêts, seul celui qui a le plus petit handle sera renvoyé.

On ne sait même pas s'il s'agit de threads

Il faudrait fouiller dans la MSDN pour voir s'il n'y aurait pas des variantes plus appropriées, mais sinon une bidouille simple pourrait être, après le premier appel, de boucler jusqu'à ce que la fonction ne renvoie rien, avec un temps d'attente nul et en retirant le dernier handle renvoyé du tableau à chaque itération.

Ah oui pas bete ! je vais regarder de ce cote, merci

**M4tthieu** · 05/07/2007, 11h39

Envoyé par Laurent Gomila

Pas forcément non. La doc indique clairement que si plusieurs objets sont prêts, seul celui qui a le plus petit handle sera renvoyé.

On ne sait même pas s'il s'agit de threads

Il faudrait fouiller dans la MSDN pour voir s'il n'y aurait pas des variantes plus appropriées, mais sinon une bidouille simple pourrait être, après le premier appel, de boucler jusqu'à ce que la fonction ne renvoie rien, avec un temps d'attente nul et en retirant le dernier handle renvoyé du tableau à chaque itération.

Superbe idee, ca marche parfaitement, et le code est bien plus harmonieux

Merci encore

**Laurent Gomila** · 05/07/2007, 12h01

Content que ça fonctionne

?

**Médinoc** · 06/07/2007, 10h03

Pour ce genre de manips, je ne vois aucun inconvénient pour des threads, processus, ou Events manuels, mais j'ai des doutes sur les ressources limitées (sémaphores, mutexes)...

Edit: Mince, ça reste légèrement ambigu:

Envoyé par MSDN (emphasis mine)

The function modifies the state of some types of synchronization objects. Modification occurs only for the object or objects whose signaled state caused the function to return. For example, the count of a semaphore object is decreased by one. For more information, see the documentation for the individual synchronization objects.

Que comprendre ?

**Médinoc** · 06/07/2007, 10h27

Ça me démangeait tellement que j'ai fait un test:

Code C :

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
void TestWait(void)
{
	HANDLE hSem1 = CreateSemaphore(NULL, 1, 1, NULL);
	HANDLE hSem2 = CreateSemaphore(NULL, 1, 1, NULL);
	HANDLE hAllSems[] = { hSem1, hSem2 };
	DWORD res = WaitForMultipleObjects(ARRAYSIZE(hAllSems), hAllSems, FALSE, 0);
	assert(res == WAIT_OBJECT_0);
 
	{
		LONG oldCount1 = -1;
		LONG oldCount2 = -1;
		BOOL bSem1Acquired = ReleaseSemaphore(hSem1, 1, &oldCount1);
		BOOL bSem2Acquired = ReleaseSemaphore(hSem2, 1, &oldCount2);
 
		printf("Sem1's boolean is %d, count is %ld.\n", bSem1Acquired, oldCount1);
		printf("Sem2's boolean is %d, count is %ld.\n", bSem2Acquired, oldCount2);
	}
	CloseHandle(hSem1);
	CloseHandle(hSem2);
}

En sortie:

Code X :

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

1
2
Sem1's boolean is 1, count is 0.
Sem2's boolean is 0, count is -1.

Donc, c'est OK : Seul l'objet retourné est réservé.

[ WaitForMultipleObjects ] Lister tous les objets signales ?

C++

Discussions similaires

Partager

Partager