Discussion :

[rdtech]

bonjour,
j'ai besoin de bloquer d'office l'accès à une ressource commune pour plusieurs threads.
Je cherche donc à "initialiser" à 0 le compteur d'un pthread_mutex_t via pthread_mutex_init() (ou tout autre moyen) de manière à ce que les pthread_mutex_lock() ne soient pas satisfaits.

Je ne trouve rien à ce propos sur le net, je prend en compte toutes les idées...

Merci.

[imperio]

Ta demande est absolument incomprehensible donc je vais faire une supposition :

Tu veux empecher la possibilite de locker un mutex par un autre ? Dans ce cas :

Code :

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

1
2
pthread_mutex_init(&mut, 0);
pthread_mutex_lock(&mut);

Ensuite si tu veux tester le mutex pour voir s'il est deja locker, je t'invite a regarder pthread_mutex_trylock.

[Bktero]

Dans le code d'imperio, rien n'empêche le thread d'être préempté entre la création et la prise du mutex et je pense que c'est ce que rdtech souhaite éviter.

Ne faudrait-il pas plutôt faire un sémaphore et créer le premier jeton au bon moment ? Ce qui me faire dire ça, c'est ce que je lis sur Wikipédia :

Exclusion mutuelle[modifier | modifier le code]
Il existe également le sémaphore binaire qui est une exclusion mutuelle (mutex). Il est toujours initialisé avec la valeur 1.

Mais en allant un peu plus loin dans la reflexion, pourquoi créer un mutex si on ne peut pas s'en servir tout de suite ? Pouquoi ne pas le créer au bon moment justement ?

[rdtech]

bonjour,
en fait, je cherche à coder le modèle producteur/consommateur que l'on trouve dans la littérature. Le thread principal créé un thread producteur et un thread consommateur dans le plus simple des cas et celui-ci ne doit pas accéder à la ressource commune avant qu'un thread producteur n'y ait déposé quoi que ce soit. D'où l'idée de bloquer d'office l'accès du consommateur avec un mutex à 0. C'est peut être pas la meilleure idée...

J'ai tenté le pthread_mutex_init(&mut, 0); mais le compilateur n'est pas content car l'argument 2 doit être de type pthread_mutexattr* et de toute façon j'ai droit à une erreur de segmentation.

Le commentaire de Bktero me donne à penser que je n'ai pas tout compris du mutex. Son initialisation ne peut peut être pas se faire à 0 et il me faut donc un sémaphore. De plus mon mon analyse n'est peut être pas terrible.

Je continue à creuser, merci.

[Bktero]

Producteur / consommateur, c'est typiquement un sémaphore

Un sémaphore, c'est quelqu'un qui fait quelque chose et crée un jeton pour indiquer qu'il a fini. Des gens vont venir consommer ces jetons, mais forcément au même rythme que celui de production et sans que le producteur s'en soucie. Un mutex protège une section particulière où une seule personne doit être présent à la fois. Il y aussi une notion de possesseur du mutex, ce qu'on ne retrouve pas dans le sémaphore.

Dans ton cas, le producteur peut commencer à produire sans que le précédent sémaphore n'est été commencé. Tu auras peut-être un mutex pour protéger l'accès à des variables partagées par le producteur et les consommateurs.

Regarde : http://en.wikipedia.org/wiki/Produce...nsumer_problem

[rdtech]

A Bktero,
merci pour l'explication et le lien.

Tchusss.