[ WaitForMultipleObjects ] Lister tous les objets signales ?

Version imprimable

03/07/2007, 18h17
M4tthieu

[ WaitForMultipleObjects ] Lister tous les objets signales ?

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 ?
04/07/2007, 09h17
M4tthieu

Personne ? :s
04/07/2007, 09h43
Damess

Bonjour.

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

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:

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.

04/07/2007, 10h45
Laurent Gomila

Citation:

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é.

Citation:

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.

Citation:

Envoyé par r0d

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
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 :)

04/07/2007, 12h44
M4tthieu

Citation:

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 :)
05/07/2007, 11h39
M4tthieu

Citation:

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 :king:

Merci encore :)
05/07/2007, 12h01
Laurent Gomila

Content que ça fonctionne ;)

:resolu: ?
06/07/2007, 10h03
Médinoc

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:

Citation:

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 ?

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

Code:

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:

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é.