Discussion :

[lomigfa]

Bonjour à tous,

Le contexte d'abord : je travaille sur un programme en C pour de l'embarqué.
Dans un premier temps j'avais déclaré mes variables qui sont utilisées dans plusieurs fonctions en globales pour ne pas être embété.
Certaines de ces variables sont lues dans un fichier de configuration au début puis utilisées régulièrement, d'autres sont mises à jour et relues par plusieurs fonctions qui tournent dans différents threads.
Je souhaite maintenant rendre le programme plus propre en évitant d'utiliser ces variables globales. Je pense qu'il faut passer par des structures que je passerais à toutes les fonctions qui en ont besoin.
Mais ces fonctions sont elles-même appelées par des theards différents, et donc je ne sais pas trop comment m'en sortir.
Ma question est donc la suivante : quelle est la "bonne" façon de faire ? C'est-à-dire la plus propre et la plus simple à la fois ?

Merci d'avance pour votre aide !

[emixam16]

Bonjour,

Que deux structures utilisent en même temps une fonction ne pose pas problème.

Par contre, si deux threads accèdent à une même variable/structure avec au moins l'un des deux en écriture, il peut y avoir des problèmes d'accès concurrents.

En C, une façon classique est d'utiliser des mutex.

Il suffit d'entourer tes accès à ta variable avec un tel mutex:

Code c++ :

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

1
2
3
4
 
pthread_mutex_lock(&mutex);
monAccesCritique();
pthread_mutex_unlock(&mutex);

Évite les variables globales. C'est rapidement difficilement maintenable. Par contre tu peux passer une structure à un thread à sa création contenant tout ce dont il aura besoin avec le dernier paramètre de pthread_create .

[sambia39]

Bonjour,
Pour commencer à faire propre dans votre code source, il est impératif et vital de synchroniser vos threads avec des mutex (c'est le minimum à faire) afin d'éviter des situations de blocage voir pire, corruption de données et ce tout simplement parce que tout thread crée en un accès immédiat et partagé à l'ensemble de vos variables globales (les descripteurs de fichiers y passent). En d'autres termes, n'importe quel thread peut modifier à tout instant la valeur de vos variables globales.

Dans le cas ou cela ne satisfait pas vos demandes, il y a la variante des mutex les R/W locks qui est un ensemble de verrous très semblables à ceux des mutex sauf qu'au moment du verrouillage, on indique juste si on souhaite seulement lire les données ou si on risque aussi de les modifier.

Initialisation de ces verous se fait de façon dynamique avec int pthread_rwlock_init(pthread_rwlock_t *rw, const pthread_rwlockattr_t *attr); ou de façon statique avec pthread_rwlock_t wr = PTHREAD_RWLOCK_INITIALIZER;

Il suffit d'entourer tes accès à ta variable avec un tel mutex:

Code c++ :

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

1
2
3
4
 
pthread_mutex_lock(&mutex);
monAccesCritique();
pthread_mutex_unlock(&mutex);

Attention, il ne suffit pas seulement d'entourer la variable globale, il faut également tester la valeur retour des fonctions qui entoure cette variable. Dans le cas présent, si elle échoue il y a une race condition qui débouche à la fin à un blocage

À bientôt,

[lomigfa]

Bonjour à tous les deux et merci pour vos réponses.

Mieux vaut éviter les variables globales donc, je m'en doutais.
Je n'ai pas trop de souci à gérer les ressources partagées avec mutex etc, je devrais m'en sortir.

Il reste une partie de la question non résolue
Si dans mon main je lis un paquet de variables en début de programme que je stocke dans des tableaux et / ou structures. Ensuite j'appele les threads qui travaillent avec ces valeurs, commennt je peux passer toutes ces variables contenues dans plusieurs tableaux / structure puisque le pthread_create permet le passage d'un seul argument seulement ?

Merci d'avance,

Guillaume

[gerald3d]

Bonjour.

Tu connais déjà la réponse je pense mais c'est toujours pareil. On utilise le principe de la poupée russe. Crées une structure qui va englober tous les tableaux et variables dont tu as besoin. tu déclares une variable du type de la structure dans le main et tu passes son pointeur au p_thread.

[lomigfa]

Ah oui, évidemment ! =)

Merci !

Guillaume