Discussion :

[Flo.]

Bonjour,

le code suivant utilise-t-il la bonne méthode pour vérifier si un mutex est bloqué ou pas ?

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
bool isMutexLocked(boost::mutex & mutex)
{
	bool locked = false;
 
	// try blocking the mutex
	{
		boost::mutex::scoped_lock lock(mutex, boost::try_to_lock); 
		if(lock.owns_lock())
		{
			locked = false;
		}
		else
		{
			locked = true;
		}		
	}
 
	return locked;
}

Merci

Flo.

[Jean-Marc.Bourguet]

A quoi ça sert? La réponse peut-être fausse dés la sortie de la fonction.

[Flo.]

Oui je sais.

Bon alors je mets un exemple plus concret.

Voici la classe Process

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
class Process
{
	mutable boost::mutex _mutex;
 
	boost::condition _condition;
 
public:
 
	boost::signals2::signal<void ()> _onWaiting;
 
	void run()
	{
		while(une_condition)
		{
			// ... on fait le taf
 
			// je lance un thread qui va envoyer le signal _onWaiting 
			// lorsque le mutex sera bloqué (signe qu'on est dans le
			// "wait" de la boost::condition)
			boost::thread(boost::bind(&Process::checkState, this));
 
			// en attente
			{
				boost::mutex::scoped_lock guard(_mutex);
				_condition.wait(guard);			
			}
		}
	}
 
	bool isWaiting()
	{
		// try blocking the mutex
		{
			boost::mutex::scoped_lock lock(_mutex, boost::try_to_lock); 
			if(lock.owns_lock())
			{
				// si on est parvenu à bloquer le mutex
				// alors on n'est pas dans le "wait" de la 
				// boost::condition
				return false;
			}	
		}
 
		return true;
	}
 
	void release()
	{
		_condition.notify_all();
	}
 
private:
 
	void checkState()
	{
		do
		{		
			// on attend avant de tester le mutex à nouveau
			boost::this_thread::sleep(boost::posix_time::milliseconds(10)); 
		}
		while(!isWaiting());
 
		_onWaiting();
	}
}; // Process

Et voilà le main

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
Process p1;
Process p2;
Process p3;
 
void testState()
{
	// une fois que les 3 threads sont en attente
	if(p1.isWaiting() && p2.isWaiting() && p3.isWaiting())
	{
		// on les libère	
		p1.release();
		p2.release();
		p3.release();
	}
}
 
int main()
{
	p1._onWaiting.connect(boost::bind(testState));
	p2._onWaiting.connect(boost::bind(testState));
	p3._onWaiting.connect(boost::bind(testState));
	p1.run();
	p2.run();
	p3.run();
}

En bref, c'est pour synchroniser plusieurs threads que j'ai procédé ainsi. Mais la fonction owns_lock() me renvoie toujours true alors que je suis bien bloqué dans le "wait" de ma boost::condition.

Pas taper hein ! Si y a mieux (et j'en doute pas) pour faire la même chose, je suis preneur.

Flo.

[Flo.]

En scrutant la doc de plus près, j'ai compris que le mutex est débloqué par la méthode wait du boost::condition. Donc mon test ne vaut rien.

En attendant une meilleure solution, j'ai utilisé un booléen

• qui passe à true avant de faire le wait
• qui passe à false après le notify_all
• qui est retourné par la fonction isWaiting()

Chacune des 3 opérations étant protégée par un 2ième mutex.

Ya pas mieux comme solution ?

Flo.

[bretus]

Bonsoir,

Je ne suis pas un gros expert en thread, mais lock est plutôt là pour entourer l'accès à une variable partagée en accès concurrent (quand on a rien de mieux)

Pour synchroniser plusieurs thread, vous n'auriez pas plutôt besoin d'un join()?

[Flo.]

En fait , j'ai plusieurs threads. Dans chacun des threads, j'ai une boucle while. Je veux qu'à la fin de chaque boucle, tous les threads s'attendent.

Flo.