Dai concetti del sistema operativo di Abraham Silberschatz, Peter B. Galvin, Greg Gagne, la soluzione di Peterson al problema della sezione critica ha due processi Pi e Pj,
do { flag[i] = true; turn = j; while (flag[j] && turn == j); critical section flag[i] = false; remainder section } while (true);Figure 5.2 The structure of process Pi in Peterson’s solution.
Perché Pi imposta turn a j anziché i ? Trovo difficile capire intuitivamente. Grazie.
Innanzitutto, il modo in cui questo algoritmo viene scritto, in particolare usando i riferimenti di matrice flag[i] e flag[j] , invece di due singole variabili, ad es. flag_p0 e flag_p1 , suggerisce al lettore che sarebbe scalabile facilmente su tre o più thread. Tuttavia , semplicemente non è il caso. L'intensa condizione del test del ciclo di attesa deve essere ingrandita per adattarsi a ogni nuovo thread, oppure i strutture dati necessarie e test cambia sostanzialmente ) per generalizzare per N thread.
Quindi nel contesto della semplice versione di due processi come originariamente sviluppato: il valore reale scritto in turn non è importante a condizione che:
Il punto è che l'altro thread non è più interessato alla risorsa protetta ( flag[j] fallisce), o, l'altro thread è interessato ma è ancora occupato in attesa ( flag[j] è true, ma il valore scritto ora è l'altro valore).
Questi due test insieme coprono non solo l'interesse per l'accesso alla risorsa protetta, ma anche problemi problematici come le condizioni di competizione che altrimenti si verificherebbero se non fosse coinvolta anche la posizione di memoria turn . In breve, ci vogliono tre parole di stato per realizzare questo algoritmo (e ogni parola in realtà ha bisogno solo di 1 bit!).
I valori specifici utilizzati per la variabile turn non sono importanti e non devono essere i per P i e j per P j ; hanno solo bisogno di essere diversi valori utilizzati nei due diversi processi.
Se lo desideri, potresti anche scrivere i in turn , ad es. per P i
flag[i] = true; // register interest
turn = i; // write to the turn variable to detect busy condition
while (flag[j] && turn == i); // test (lack of interest or busy wait) by Pj
finché P j viene regolato in modo simile.
Oppure potremmo metterlo a tacere fino all'essenza senza l'allusione (probabilmente errata) alla versione generalizzata del thread N che usa gli array, poiché ci sono solo due processi supportati nell'algoritmo originale. Qui per P 0
flag_p0 = true; // register interest
busy = 100; // write to the turn variable to detect busy condition
while (flag_p1 && busy == 100); // test (lack of interest or busy wait) by p1
E per P 1
flag_p1 = true; // register interest
busy = 200; // write to the turn variable to detect busy condition
while (flag_p0 && busy == 200); // test (lack of interest or busy wait) by p0
Leggi altre domande sui tag synchronization