Révision Express — Systèmes d'Exploitation II

/* Structure typique d'un processus Pi */
do {
    entry_section() ;    // Demande d'accès à la SC
    /* ═══ SECTION CRITIQUE ═══ */
    // Modifier variables communes, écrire fichier...
    exit_section() ;     // Libération de la SC
    /* Remainder section */
} while (true) ;

Un sémaphore S est constitué de : un compteur entier + une file d'attente F de processus bloqués.

/* n processus partagent un sémaphore mutex initialisé à 1 */
Semaphore mutex = 1;

repeat
    wait(mutex);          // Entrée SC
    /* section critique */
    signal(mutex);        // Sortie SC
    /* remainder section */
until false;

// Déclaration
sem_t mutex;

// Initialisation : pshared=0 (thread local), value=valeur init
sem_init(&mutex, 0, 1);

// Attente (décrémente) — BLOQUANT
sem_wait(&mutex);

// Attente (décrémente) — NON BLOQUANT (retourne -1 si occupé)
sem_trywait(&mutex);

// Libération (incrémente + réveille un processus si file non vide)
sem_post(&mutex);

// Lire valeur courante
sem_getvalue(&mutex, &sval);

// Destruction
sem_destroy(&mutex);

Un producteur génère des données placées dans un tampon de N cases, qu'un consommateur retire. Gestion : Overflow Underflow

/* Producteur */                    /* Consommateur */
repeat                               repeat
  produire nextp                         wait(full)
  wait(empty)   // case disponible?    wait(mutex)
  wait(mutex)   // accès exclusif     retirer item
  ajouter nextp au buffer              signal(mutex)
  signal(mutex)                        signal(empty)  // libère case
  signal(full)  // case remplie       consommer item
until false;                         until false;

Accès concurrent à une base de données. Plusieurs lecteurs simultanément OK. Un rédacteur → accès exclusif total.

• mutex = 1 : protège la variable NbL (compteur de lecteurs)
• redact = 1 : exclusion mutuelle pour les rédacteurs
• NbL = 0 : nombre de lecteurs actifs
• 1er lecteur → wait(redact) ; Dernier lecteur → signal(redact)

5 philosophes autour d'une table, 5 fourchettes. Pour manger : besoin des 2 fourchettes adjacentes.

Solutions : limiter à 4 philosophes à table, prendre 2 fourchettes atomiquement, asymétrie (philosophe pair/impair). C'est aussi un modèle du problème d'inter-blocage.

class CompteBancaire {
    private int solde = 0;

    // synchronized → une seule méthode active à la fois
    public synchronized void deposer(int montant) {
        solde = solde + montant;
    }

    public synchronized void retirer(int montant) {
        if (solde >= montant)
            solde = solde - montant;
    }
}