Discussion :

[ep31]

J'ai deux exe, chacun essayant d'accéder à une ressource partagée.
J'ai une méthode de réservation de la ressource :

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
 
bool Mutex::_WaitFor ()
{
	try {
		DWORD dwWaitResult = WaitForSingleObject (m_Mutex, m_WaitingForMutex);
		switch (dwWaitResult)
		{
			case WAIT_OBJECT_0 :
				m_CurrentErr = "";
				return true;
			case WAIT_TIMEOUT :
				throw ExceptionWaitTimeOutMutex();
			case WAIT_FAILED :
				throw ExceptionWaitFailedMutex();
			default :
				throw ExceptionUnknowMutex();
		}
	}
	catch (ExceptionWaitTimeOutMutex e) {
		m_CurrentErr = e.GetError();
		return false;
	}
	catch (ExceptionWaitFailedMutex e) {
		m_CurrentErr = e.GetError();
		return false;
	}
	catch (ExceptionUnknowMutex e) {
		m_CurrentErr = e.GetError();
		return false;
	}
	catch (...) {
		m_CurrentErr = static_cast<CString>("Could not access to mutex");
		return false;
	}
}

et une pour la libération :

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
 
bool Mutex::Release ()
{
	try {
		BOOL	bReleased = FALSE;
		if ((bReleased =ReleaseMutex(m_Mutex)) == TRUE) 
			bReleased = CloseHandle (m_Mutex);
		if (bReleased == FALSE)
			m_CurrentErr = static_cast<CString>("Could not release mutex");
		m_Mutex = 0;
		return true ? bReleased == TRUE : false;
	}
	catch (...) {
		m_CurrentErr = static_cast<CString>("Could not release mutex");
		return false;
	}
}

Je lance mes deux exe (e1 et e2) en parallèle.
_ e2 essaie de réserver la ressource partagée alors que e1 est en train d'y travailler dessus (donc ne l'a pas libérée mais l'a réservée). e1 libère la resource (par Release()) mais e2 ne peut toujours pas y accéder. Il attend que l'exécutable e1 ait fini son traitement et se kille pour pouvoir réserver la ressource.
_ Par contre, si e1 réserve la resource et la libère, e2 peut la réserver et l'utiliser ; e1 peut ensuite la réserver puis la libérer, ...
Si un de mes exe réserve la resource et la libère, un autre process peut y accèder. Par contre, si un exe essaie d'y accèder alors que l'autre ne l'a pas libérée ; alors le process attendant la resource est obligé d'attendre que l'autre process soit totalement fini.

J'ai été clair j'espère ?

[ep31]

Au fait, ma question est : qu'est-ce qu'il faut ajouter comme option (lors du CreateMutex ou de l'OpenMutex) pour éviter ce problème svp ?
D'ailleurs voilà la méthode de création du mutex :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
bool Mutex::_Open ()
{
	try {
		if (m_Mutex == 0) 
			if (!(m_Mutex = OpenMutex (SYNCHRONIZE, TRUE, m_MutexName))) 
				m_Mutex = CreateMutex (NULL, FALSE, m_MutexName);
		return true;
	}
	catch (...) {
		return false;
	}
}

[ep31]

OK, c'était l'appel succéssif à WaitForSingleObject qui considérait que je prenais plusieurs jetons apparement.