Probleme de gestion de semaphore

Version imprimable

Bonjour,
Je viens de manipuler une sémaphore dans mon projet.
Mon problème c'est que la fonction WaitForSingleObject() ne prend pas d'effet même si je la configure avec le paramètre INFINITE.
C'est à dire lorsque je fais deux appel consécutif de la fonction WaitForSingleObject() ca passe toujours.
Voici un exemple qui illustre mon problème

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
93
94
95
96
97
98
99
100
101
102
// TestMutex.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <stdio.h>
#include <winsock2.h>
#include <WinBase.h>
 
HANDLE SemMutex;
 
void Funct1 (void)
{
	int err = 0;
	DWORD dwWaitResult;
 
	SemMutex = CreateMutex (NULL, // default security attributes
                            FALSE, // initially not owned
                            NULL // unnamed mutex
                            );
 
    if (SemMutex == NULL)
    {
        // An error has occurred
        err = 1;
    }
 
	dwWaitResult = WaitForSingleObject (SemMutex, // handle to mutex
                                        INFINITE // no time-out interval
										);
 
    /*if (ReleaseMutex (SemMutex) != 0)
    {
        err = 1;
    }
 
    if (CloseHandle (SemMutex) != 0)
    {
        err = 1;
    }*/
}
 
void Funct2 (void)
{
	int err = 0;
	DWORD dwWaitResult;
 
	Sleep (2000);
 
	SemMutex = CreateMutex (NULL, // default security attributes
                            FALSE, // initially not owned
                            NULL // unnamed mutex
                            );
 
    if (SemMutex == NULL)
    {
        // An error has occurred
        err = 1;
    }
 
	dwWaitResult = WaitForSingleObject (SemMutex, // handle to mutex
                                        INFINITE // no time-out interval
										);
 
    /*if (ReleaseMutex (SemMutex) != 0)
    {
        err = 1;
    }
 
    if (CloseHandle (SemMutex) != 0)
    {
        err = 1;
    }*/
}
 
int _tmain(int argc, _TCHAR* argv[])
{
 
	HANDLE HandleTh1;
	HANDLE HandleTh2;
	DWORD ECRthreadID1;
	DWORD ECRthreadID2;
 
	HandleTh1 = CreateThread (NULL, //Choose default security
                                      0, //Default stack size
                                      (LPTHREAD_START_ROUTINE) &Funct1, //Routine to execute
                                      NULL, // No parameter
                                      0, // Immediately run the thread
                                      &ECRthreadID1 //Thread Id
                                      );
 
	HandleTh1 = CreateThread (NULL, //Choose default security
                                      0, //Default stack size
                                      (LPTHREAD_START_ROUTINE) &Funct2, //Routine to execute
                                      NULL, // No parameter
                                      0, // Immediately run the thread
                                      &ECRthreadID2 //Thread Id
                                      );
 
	Sleep (30000);
 
	return 0;
}

Est ce que quelqu'un peux m'aider?
Merci

10/09/2013, 19h48
bacelar

Vérifiez la valeur de retour "dwWaitResult", svp.

Bonjour.

Il y a un exemple d'utilisation des mutex ici :

http://msdn.microsoft.com/en-us/libr...(v=vs.85).aspx

Le problème que je vois c'est que le mutex est créé deux fois. Donc le handle du premier appel est perdu au deuxième appel. Ce n'est plus le même sémaphore et il y a une fuite de mémoire.

Plutôt un truc de ce genre :

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
// TestMutex.cpp : Defines the entry point for the console application.
//
 
#include <stdio.h>
#include <winsock2.h>
#include <WinBase.h>
 
HANDLE SemMutex;
 
void Funct1 (void){
 
  int err = 0;
  DWORD dwWaitResult;	
 
  if(SemMutex == NULL){
    // An error has occurred
    err = 1;
  }
 
  dwWaitResult = WaitForSingleObject (SemMutex, // handle to mutex
				INFINITE // no time-out interval
				);
 
  /*if (ReleaseMutex (SemMutex) != 0)
  {
     err = 1;
  }
 
  if (CloseHandle (SemMutex) != 0)
  {
    err = 1;
   }*/
}
 
void Funct2 (void){
 
  int err = 0;
  DWORD dwWaitResult;
 
  Sleep (2000);
 
  if(SemMutex == NULL){
    // An error has occurred
    err = 1;
  }
 
  dwWaitResult = WaitForSingleObject (SemMutex, // handle to mutex
			          INFINITE // no time-out interval
  			);
 
  /*if (ReleaseMutex (SemMutex) != 0)
  {
     err = 1;
  }
 
  if (CloseHandle (SemMutex) != 0)
  {
     err = 1;
   }*/
}
 
void main(){
 
  HANDLE HandleTh1;
  HANDLE HandleTh2;
  DWORD ECRthreadID1;
  DWORD ECRthreadID2;
 
  SemMutex = CreateMutex (NULL, // default security attributes
                          FALSE, // initially not owned
     	      NULL // unnamed mutex
  	);
 
  HandleTh1 = CreateThread (NULL, //Choose default security
                                      0, //Default stack size
                                      (LPTHREAD_START_ROUTINE) &Funct1, //Routine to execute
                                      NULL, // No parameter
                                      0, // Immediately run the thread
                                      &ECRthreadID1 //Thread Id
                                      );
 
  HandleTh2 = CreateThread (NULL, //Choose default security
                                      0, //Default stack size
                                      (LPTHREAD_START_ROUTINE) &Funct2, //Routine to execute
                                      NULL, // No parameter
                                      0, // Immediately run the thread
                                      &ECRthreadID2 //Thread Id
                                      );
 
  Sleep (30000);
}

Ici la fonction 2 se bloque bien par ce que la fonction 1 ne Release pas le sémaphore.

10/09/2013, 23h32
midou256

Merci moldavi pour la réponse mais je pense que CreateMutex () crée une semaphore s'il n'existe pas sinon elle renvoie le même handle qui a été créé.
En fait j'ai essayé d'exécuter le code avec la modification que tu as fournis mais malheureusement toujours le même problème persiste.
10/09/2013, 23h50
midou256

La fonction dwWaitResult() retourne toujours la valeur 0. Je pense que c'est WAIT_OBJECT_0 (The state of the specified object is signaled).
11/09/2013, 10h41
Médinoc

Citation:

Envoyé par midou256

Merci moldavi pour la réponse mais je pense que CreateMutex () crée une semaphore s'il n'existe pas sinon elle renvoie le même handle qui a été créé.

Seulement s'il est nommé. Si tu ne lui passes aucun nom, CreateMutex() crée à chaque fois un nouveau mutex anonyme.

PS: Mutex et sémaphore sont deux choses différentes.
PPS: Cette question n'a rien à voir avec le Framework .Net ou le langage C++/CLI.
11/09/2013, 13h26
midou256

Ah ok ;)
Mais le problème persiste meme si je fais une seul appel de la fonction CreateMutex (). :calim2:
11/09/2013, 14h19
bacelar

Avez-vous vérifié la valeur de err avant l'appel à WaitForSingleObject ?
(moi, j'aurais mis l'appel de WaitForSingleObject dans le else du "if (SemMutex == NULL)"
11/09/2013, 17h19
midou256

La valeur de SemMutex est différente de null.
Lorsque je fais l'appel de la fonction CreateMutex () une seul fois, le deuxième appel de la fonction WaitForSingleObject() retourne la valeur 128 (0x00000080L) WAIT_ABANDONED alors que la fonction doit être bloqué jusqu'à ce que un release de la sémaphore aura lieux.
11/09/2013, 17h40
bacelar

Cf. la Doc:
http://msdn.microsoft.com/en-us/libr...(v=vs.85).aspx
11/09/2013, 20h29
moldavi

Bonjour.

Pouvez-vous poster le code exact que vous utilisez ?

Le mien fonctionne parfaitement sur ma machine.

Si vous utilisez exactement mon code, je posterai une version qui prends mieux en compte les gestions d'erreurs.

EDIT: OK, j'ai compris. Vous n'avez pas repris mon code et vous avez laissé la création du mutex dans le premier thread. Ce qui provoque le WAIT_ABANDONED. Dans le code que j'ai fourni, la création du mutex est dans le main, c'est à dire dans le thread principal de l'application.

En effet, le thread qui a créé le mutex ne l'a pas "Release", et en plus le thread est "mourru". D'où le WAIT_ABANDONED. En effet le thread 1 ne pourra jamais "Release" le mutex puisqu'il est "mourru". Et donc pour éviter un blocage sur le "Wait" (dans le cas de "INFINITE"), le "Wait" renvoit WAIT_ABANDONED. Cela permet de corriger son programme lorsque l'on rencontre ce message.

EDIT2: des explications ici : http://www.developpez.net/forums/d88...st-pas-genere/

J'ai fais la création du sémaphore dans la fonction main
voici le 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
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
 
// TesyMutex.cpp*: définit le point d'entrée pour l'application console.
//
 
#include "stdafx.h" 
#include <stdio.h>
#include <winsock2.h>
#include <WinBase.h>
 
HANDLE SemMutex;
 
void Funct1 (void)
{ 
  DWORD dwWaitResult;
 
  dwWaitResult = WaitForSingleObject (SemMutex, // handle to mutex
						     INFINITE // no time-out interval
						    );
 
  printf ("Thread 1: WaitForSingleObject() returns %d\n", dwWaitResult);
 
  // ReleaseMutex (SemMutex);
}
 
void Funct2 (void)
{ 
  DWORD dwWaitResult;
 
  Sleep (2000);
  dwWaitResult = WaitForSingleObject (SemMutex, // handle to mutex
						     INFINITE // no time-out interval
						    );
 
  printf ("Thread 2: WaitForSingleObject() returns %d\n", dwWaitResult);
 
  // ReleaseMutex (SemMutex);
}
 
int _tmain(int argc, _TCHAR* argv[])
{
	char c;
	HANDLE HandleTh1;
	HANDLE HandleTh2;
	DWORD ECRthreadID1;
	DWORD ECRthreadID2;
 
	SemMutex = CreateMutex (NULL, // default security attributes
					     FALSE, // initially not owned
 					     NULL // unnamed mutex
				           );
 
	if(SemMutex == NULL)
	{
		// An error has occurred
		printf ("Error to create semaphore\n");
		return 0;
	}
 
	HandleTh1 = CreateThread (NULL, //Choose default security
					      0, //Default stack size
					      (LPTHREAD_START_ROUTINE) &Funct1, //Routine to execute
					      NULL, // No parameter
					      0, // Immediately run the thread
					      &ECRthreadID1 //Thread Id
					      );
 
	HandleTh2 = CreateThread (NULL, //Choose default security
					      0, //Default stack size
					      (LPTHREAD_START_ROUTINE) &Funct2, //Routine to execute
					      NULL, // No parameter
					      0, // Immediately run the thread
					      &ECRthreadID2 //Thread Id
					     );
 
	WaitForSingleObject (HandleTh2, INFINITE);
	WaitForSingleObject (HandleTh1, INFINITE);
 
	CloseHandle (SemMutex);
 
	scanf ("Press any key to exit", &c);
	return 0;
}

11/09/2013, 23h33
moldavi
Bonjour.

Autant pour moi, désolé.

Il faut intiialiser le mutex comme ceci :
Code:

1 2 SemMutex = CreateMutex(NULL, TRUE, NULL);
Le deuxième paramètre à "TRUE" au lieu de FALSE.

PS: j'éditerai mon message précédent plus tard pour le corriger.
12/09/2013, 01h02
midou256

oui mais j'ai constaté que la fonction WaitForSingleObject se bloque dans les deux threads 8O