Probleme de gestion de semaphore

**midou256** · 10/09/2013, 19h19

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 :

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

**bacelar** · 10/09/2013, 20h48

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

**moldavi** · 10/09/2013, 21h13

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 :

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

**midou256** · 11/09/2013, 00h32

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.

**midou256** · 11/09/2013, 00h50

La fonction dwWaitResult() retourne toujours la valeur 0. Je pense que c'est WAIT_OBJECT_0 (The state of the specified object is signaled).

**Médinoc** · 11/09/2013, 11h41

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.

**midou256** · 11/09/2013, 14h26

Ah ok

Mais le problème persiste meme si je fais une seul appel de la fonction CreateMutex ().

**bacelar** · 11/09/2013, 15h19

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

**midou256** · 11/09/2013, 18h19

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.

**bacelar** · 11/09/2013, 18h40

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

**moldavi** · 11/09/2013, 21h29

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/

**midou256** · 12/09/2013, 00h15

J'ai fais la création du sémaphore dans la fonction main
voici le code

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
 
// 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;
}

**moldavi** · 12/09/2013, 00h33

Bonjour.

Autant pour moi, désolé.

Il faut intiialiser le mutex comme ceci :

Code :

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

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.

**midou256** · 12/09/2013, 02h02

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

Probleme de gestion de semaphore

C++/CLI

Discussions similaires

Partager

Partager