Discussion :

[Vodlich]

Bonsoir,

J'ai un peu de mal à comprendre comment utiliser les mutexs et conditions.
Quelques questions :
-Faut-il déclarer un mutex par variable globale partagée?
-Peut-on utiliser les mutexs et conditions autre part que dans un thread?

Si quelqu'un peut m'orienter vers des exemples où 2 threads modifie une variable globale "en même temps" pour que je saisisse comment ça marche, à par les pages du man, j'ai rien trouvé qui m'éclaire.

Merci d'avance

[fearyourself]

Regarde la section Arrays

http://www.cs.cf.ac.uk/Dave/C/node32.html

[Emmanuel Delahaye]

Si quelqu'un peut m'orienter vers des exemples où 2 threads modifie une variable globale "en même temps" pour que je saisisse comment ça marche, à par les pages du man, j'ai rien trouvé qui m'éclaire.

http://emmanuel-delahaye.developpez.com/pthreads.htm

[Vodlich]

Merci pour ces liens. Je vais étudier tout cela.

[Vodlich]

Une question, est-ce qu'un pthread_cond_wait(&condition, &mutex) attend forcement un pthread_cond_signal(&condition) (ou autre de la même famille) pour passer à la suite ou bien si le mutex est deverouillé, il n'attend pas et passe directement à la suite ?

Et encore la même question, faut-il un couple mutex condition pour chaque variable partagée ou bien un seul pour toutes les variables partagées ?

Merci d'avance.

[fearyourself]

De la page manuel de pthread_cond_wait:

pthread_cond_wait déverrouille atomiquement le mutex
(comme pthread_unlock_mutex) et attend que la variable
condition cond soit signalée. L'exécution du thread est
suspendu et ne consomme pas de temps CPU jusqu'à ce que la
variable condition soit signalée. Le mutex doit être ver*
rouillé par le thread appelant à l'entrée de
pthread_cond_wait. Avant de rendre la main au thread
appelant, pthread_cond_wait reverrouille mutex (comme
pthread_lock_mutex).

Déverrouiller le mutex et suspendre l'exécution sur la
variable condition est effectué atomiquement. Donc, si
tous les threads verrouillent le mutex avant de signaler
la condition, il est garanti que la condition ne peut être
signalée (et donc ignorée) entre le moment où un thread
verrouille le mutex et le moment où il attend sur la vari*
able condition.

Donc il faut que le mutex soit verouille (que le thread qui lance le pthread_cond_wait ait possession du mutex) pour que l'appel fonctionne. Et en lisant les pages manuels, ils disent que c'est avec l'appel pthread_cond_signal que les threads se reveillent par la suite... Le fait que le mutex se libere n'importe pas puisque de toute facon, pthread_cond_wait libere lui-meme le mutex en question...

Et encore la même question, faut-il un couple mutex condition pour chaque variable partagée ou bien un seul pour toutes les variables partagées ?

Cela depend du programme. Imagine que j'ai un tableau et que je sais que les lectures/ecritures se font soit sur les elements d'indice pair, soit les elements d'indices impairs.

J'ai deux solutions:

- Avoir un mutex pour tout le tableau
- Avoir deux mutex: un pour les pairs et un autre pour les impairs...

Donc pour repondre a ta question, cela depend de si tu arrives/peux diviser les ressources. Un autre probleme, si tu divises trop tes ressources et necessitent donc beaucoup de mutex, tes threads ne vont pas arretes d'etre en attente pour une ressource, puis une autre, puis une autre... Ne parlons meme pas du risque d'interblocage...

[Pouic]

Attention tout de même : si un pthread_cond_signal est émis et qu'aucun thread n'est en mesure de le recevoir (ie sur un pthread_cond_wait), alors ce signal est perdu. Et si par la suite un thread se met en attente de ce même signal, il risque d'attendre longtemps...

[Vodlich]

Si j'ai bien compris, lors d'une lecture ou écriture de ma variable partagée, je fais ceci :

Code :

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

1
2
3
4
5
6
7
pthread_mutex_lock(&verrou);
pthread_cond_wait(&condition, &verrou);
 
/* lecture ou ecriture de la variable partagée */
 
pthread_mutex_unlock(&verrou);
pthread_cond_signal(&condition);

Et donc le thread exécutant ce code sera en attente jusqu'à ce qu'il y ait un pthread_cond_signal(&condition) ailleurs.

c'est bien cela?

[fearyourself]

c'est bien cela?

Non, pour un mutex, c'est simplement:

Code :

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

1
2
3
4
5
6
 
pthread_mutex_lock(&verrou);
 
/* lecture ou ecriture de la variable partagée */
 
pthread_mutex_unlock(&verrou);

pthread_cond_wait s'utilise dans le cas où on attends une condition particulière... Regarde l'exemple de la page manuel:

http://www.linux-kheops.com/doc/man/...ait.3.txt.html

[Vodlich]

Merci pour votre aide.
Je pense avoir saisi le principe. En fait, je n'ai pas besoin de condition dans mon cas (vu que j'ai des threads qui modifient de manière continu mes variables partagées sans attendre quoi que ce soit des autres threads).
Je vais appliquer cela et je vous tiens au courant.

[Vodlich]

Après application, tout marche pour le mieux
Merci à vous tous pour votre précieuse aide.