EnglishCommencer

Producteur-consommateur, lecteurs-rédacteurs, philosophes

Les trois problèmes classiques de synchronisation, leur risque et leur solution type : le tampon borné à deux sémaphores et un mutex, la priorité entre lecteurs et rédacteurs, le dîner des philosophes et ses remèdes.

  • 23 cartes
  • 5 thèmes
  • Gratuit
Réviser ce deck

Le programme, thème par thème

Le poids de chaque thème suit celui que lui donne l'examen.

  1. Notions
  2. Questions
  3. Ranger et relier
  4. Mises en situation
  5. Comprendre

Quelques cartes du deck

  • Problème du producteur-consommateur : de quoi s'agit-il ?

    Voir la réponse

    Des threads déposent des éléments dans une file de taille limitée pendant que d'autres les retirent : il faut attendre quand elle est pleine ou vide.

    Solution type : deux sémaphores qui comptent les cases libres et occupées, et un mutex pour protéger les index du tampon.

  • Dans cette version du producteur, que se passe-t-il quand le tampon est plein ?

    ```c
    P(&mutex);
    P(&vide);
    deposer(x);
    V(&mutex);
    V(&plein);
    `

    • Il dort sur vide en tenant mutex : aucun consommateur ne retire
    • Il dépose quand même et écrase la plus ancienne case occupée du tampon
    • P(&vide) échoue et le dépôt est simplement ignoré par le producteur
    • Rien : le consommateur retire pendant que le producteur dort sur vide
    Voir la réponse

    Il dort sur vide en tenant mutex : aucun consommateur ne retire

    Le consommateur doit faire P(mutex) pour retirer, mais le producteur le détient en dormant. L'ordre correct est P(vide), puis P(mutex).

  • Dans le tampon borné de N cases, le sémaphore … compte les cases libres (initialisé à N) et le sémaphore … compte les cases occupées (initialisé à 0).

    Voir la réponse

    Dans le tampon borné de N cases, le sémaphore vide compte les cases libres (initialisé à N) et le sémaphore plein compte les cases occupées (initialisé à 0).

    Le producteur fait P sur « vide » puis V sur « plein » ; le consommateur fait l'inverse. Un troisième sémaphore, le mutex, protège les index.

  • Problème des lecteurs-rédacteurs : de quoi s'agit-il ?

    Voir la réponse

    Une donnée est lue par plusieurs threads et modifiée par d'autres : les lectures peuvent se chevaucher, mais une écriture exige d'être seule.

    Le choix de priorité décide de qui peut subir la famine : donner la priorité aux lecteurs peut affamer les rédacteurs, et inversement.

  • Un cache est lu mille fois par seconde et mis à jour une fois par minute, mais la mise à jour n'aboutit jamais. Quel problème classique reconnaît-on ?

    • Lecteurs-rédacteurs : le rédacteur est affamé par les lecteurs
    • Producteur-consommateur, avec un tampon trop petit pour le débit
    • Dîner des philosophes, avec une fourchette qui manque à la table
    • Un interblocage entre le cache et la base de données du service
    Voir la réponse

    Lecteurs-rédacteurs : le rédacteur est affamé par les lecteurs

    Les lecteurs se chevauchent sans cesse, donc la donnée n'est jamais libre pour le rédacteur. Un interblocage figerait aussi les lecteurs, or ici ils continuent.

Réviser ce deck