Tester si un mutex est bloqué

Version imprimable

Bonjour,

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

Code:

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.

06/09/2012, 14h40
Jean-Marc.Bourguet

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

Oui je sais.

Bon alors je mets un exemple plus concret.

Voici la classe Process

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

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.

06/09/2012, 16h33
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.
08/09/2012, 01h01
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()?
13/09/2012, 11h05
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.
13/09/2012, 15h21
Arzar

Bonjour,

Citation:

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

Dans ce cas la primitive de synchronisation appropriée me semble être la barrière : Une barrière est un point de synchronisation entre plusieurs threads. Elle est configurée pour bloquer un certain nombre de thread (n). Au départ la barrière est dans un état fermée et lorsqu'un thread arrive sur cette barrière, il doit attendre que les n autres threads arrivent à leur tour sur la barrière. Une fois que les n thread ont atteint la barrière, la barrière s'ouvre, les threads repartent et passent la barrière, puis la barrière se referme à nouveau.

Boost fournit une implémentation toute prête de barrière dans <boost/thread/barrier.hpp>

L'interface est volontairement simpliste et le code est très simple. C'est un bon point de départ pour créer un composant plus évolué, si besoin il y a.
13/09/2012, 16h03
Flo.

Merci, c'est exactement ce que je voulais.

Flo.