Partage de ressources: Mutex, Spinlock, sémaphore

[ElGato]

Salut les calés en OS,

Histoire de pas paraître trop ridicule pendant mes partiels, je dois réviser mes cours d'OS, sujet que je hais, que je méprise, si je le croise dans une rue sombre je lui pète la gueule. Bref.


Au milieu de mes centaines d'incompréhensions, y'a un truc qui me titille tout particulièrement, c'est le mécanisme de partage de ressources...j'ai cherché sur Internet mais c'est rarement très clair pour un noob comme moi - part exemple, j'ai déjà vu le cours d'OS sur developpez.com.

J'ai compris que les techniques traditionnelles (par opposition aux trucs comme les moniteurs...techniques "récentes"), 'il y avait en gros le spinlock, le sémaphore, le mutex (une version particulière du sémaphore ?).



J'arrive pas trop à comprendre toutes les différences, comment ça marche, comment ça se met en oeuvre, donc je viens vous demander votre avis...Merci d'avance !

[Popal]

Salut,

Merci pour ton message, il me rassure de savoir que je n'ai plus besoin de savoir comment tous ces trucs marchent :D !

Popal

[Flaggados]

Salut !

Alors, je ne suis pas hyper calé, mais d'après mes souvenirs en assembleur et micro-contrôleurs, le sémaphore est une sorte de liste d'attente qui gère le nombre de programmes qui peuvent se connecter simultanément à une ressource partagée, et qui bloque ou non l'exécution d'un programme en fonction de la disponibilité de la dite ressource.

L'article sur wikipédia explique un peu son fonctionnement :
http://fr.wikipedia.org/wiki/S%C3%A9maphore_(informatique)

[unpierrot]

Mutex : (contraction de mutual exclusion) C'est un objet qui ne possède qu'un possesseur. Quand un thread le possède, aucun autre thread ne peut l'obtenir.
Donc un thread demande cet objet, s'il l'obtient, il continue son execution, sinon il attend d'obtenir l'objet. Quand on accède à un mutex, il faudra le libérer en fin de traitement.
Exemple pratique : j'ai un thread qui capture l'image de ma carte vidéo et un autre qui sauvegarde les images sur mon disk en utilisant le même buffer image. Lorsque le thread de capture récupère le contenu, il ne faut pas que celui qui fabrique une image vienne lire le buffer car il est en train d'être modifié. On peut utiliser le mutex afin que les deux actions ne se fassent pas en même temps.

Semaphore : identique au mutex sauf qu'il possède un compteur, donc on peut avoir plusieurs threads possédant le semaphore en même temps.
Exemple : J'ai un tableau à n entrées qui est utilisé par des threads, si le compteur atteint n, je n'ai plus de place donc je stoppe l'accès à ce tableau afin de ne pas permettre à un (n+1)ème thread de venir mettre un élement dans le tableau plein. Quand une place se libère, je décrémente le compteur permettant à un nouveau thread d'accèder au tableau.

Spinlock : blocage par attente. Le blocage est effectif tant qu'une condition n'est pas réalisée.

[Pipeman]

Unpierrot, c'est beau, c'est clair. Bravo.