Forum Clubic

[Résolu][C / C++] Sémaphore, tel est la question

Salut amis codeurs,

Il m’arrive d’utiliser des threads (notamment pour les communications avec les sockets) mais il revient toujours une question identique lorsque je les utilise.

Dois-je utiliser des sémaphore quand j’ACCEDE à une variable (sans la modifier). La documentation que j’ai lue à ce sujet est un peu vague.

Il me paraît claire que quand j’accède à une variable (et en particulier un tableau) je dois utiliser ces méchanisme de synchronisation) mais quand je veux juste y lire le contenu?

Ca dépend de ce que tu peux faire sur la variable : si la variable est constante ou simplement non mutable, ou si elle n’est pas destinée à bouger durant le temps imparti aux threads vivantes (donc tu peux déjà oublier cette condition), alors pas besoin de synchroniser : tu ne peux pas la modifier => donc la lecture ne pose pas le problème du

int id = getId();
if ( id != getId() ) std::cout << "ouais !!!" << std::endl;

Ici, si getId() renvoyait quelque chose de constant, y aurait pas de souci.

S’il n’y a pas de modif, pas besoin de faire une exclusion mutuelle :slight_smile:

Tu veux dire, constant, de type constant?
Comme:

const int i = 3;

ou constant dans le temps, c’est à dire que i peut-être déclaré comme ça, mais la variable ne bougera quand même pas d’un poile

int i = 3;

Autre question, ne-penses tu pas qu’il faut synchroniser juste pour des handles (deux accès en console en même temps :paf: ) ou pour des tableaux (deux strcat simultanés :paf: )?

Dans le cas d’un char simple (pas contenu dans un tableau, juste 1 octet) il n’y a pas de risque que deux threads puissent se mélanger les pinceaux, donc pas besoin de sémaphore.

Aurais-je juste :heink:?

EDIT: Ok “jeanguy” et “Sans-Nom” j’ai eu la réponse à ma première question, c’était une question qui me gênait vraiment. Ouf, je vais pouvoir dormir ce soir :pt1cable:

Je ne sais pas si vous pouvez aussi donner un avi sur la deuxième question :sarcastic: (dans le cas d’un simple octet)

Ca dépend de ce que tu fait du char.

Si chaque thread fait un increment sur la valeur précédente (c = c+1 par ex), il faudrait mieux protéger par une critical section…

theFly-> oui, car il y modification de la valeur, il faut garantir que cette modification sera faite par un seul thread à la fois.

Ca pourrait rendre le programme instable juste pour une toute petite variable (1 octet) qui serait accessible par deux threads en même temps.

Ha ok, donc je prends note et je corrige mes codes :D. Je croyais que ces synchro. n’étaient utiles que pour des grosses variables que l’ont manipule en plusieurs étapes.

EDIT: Ok, merci beaucoup à tout le monde. C’est dingue comme le forum clubic est réactif, je ne me l’imaginais pas aussi vivant :sol:

Dusty-> peu importe la taille, à partir du moment où il y a risque qu’une donnée soit modiffiée par 2 threads, qu’un thread la modifie et l’autre la lise, il faut proteger cette donnée avec un mutex (semaphore).

C gentil de dire ça, nous sommes émus :’(

:ane:

Alors, la lecture de truc de taille inférieure ou égales à 4 octets est atomique, mais à partir de là ça sert pas trop si un autre idiot modifie cela derrière.

Bon, pour le reste méfie toi de la libc :slight_smile: les fichiers en particuliers (FILE*) ne sont pas trop thread safe.