L'algoritmo a due processi di esclusione reciproca di Peterson tiene conto dei processi di morte?

Penso che nell'algoritmo di Peterson per l'esclusione reciproca , se il processo prima di entrare nella sezione critica dovesse morire o essere cancellato, l'altro processo sarebbe in loop per sempre, in attesa di entrare nella sezione critica.

Nella figura, se il processo 1 viene interrotto, il resto dei processi dietro il processo 1 verrà eseguito fino a dove si trova il processo 1 ma poi il ciclo.

Cosa succede se il processo che raggiunge la sezione critica muore prima di lasciarlo?

Questo dipende da come vengono implementati i blocchi. Se lo fai come nell'articolo di Wikipedia, vale a dire proteggere la sezione critica con un valore booleano per processo¹, sei sicuramente nei guai. Se un processo muore, non ripristina mai la sua bandiera, quindi l'altro processo scorre per sempre.

In pratica, puoi proteggere il tuo codice da molti modi di morire. Ad esempio, prendi questa implementazione in stile Java:

flag[1] = true;
turn = 1;
while ( flag[0] == true && turn == 1 ) { Thread.yield(); }
try {
  // critical section
}
finally {
  flag[1] = false;
}

Ciò assicurerà che il flag venga ripristinato qualunque cosa accada nella sezione critica, purché il sistema gestisca l'errore. In Java, questo vale anche per gli overflow di stack e heap. Quindi, a meno che il processo non svanisca letteralmente ( kill², errore del processore, disconnessione della rete, ...), sei al sicuro. Si noti che la maggior parte dei software non critici fallisce in questi casi: come può gestire un errore che non è in esecuzione? - quindi deve essere accettato in molti casi. Se necessario, è possibile gestire le incoerenze al riavvio.

Se si utilizzano i blocchi appropriati a livello di lingua, il sistema di runtime può gestire i proprietari di blocchi che spariscono, ovvero rilasciare i blocchi con proprietari morti. Puoi simularlo tu stesso dando ad ogni processo un interruttore del morto che gli altri possono leggere, oppure controlla direttamente se il processo di possesso del blocco è ancora attivo (se il sistema lo supporta).

1. Questo non si adatta bene, comunque.
2. In Java, penso che finalizedovrebbe essere eseguito anche su kill, ma questo non è garantito dalle specifiche. kill -9è probabilmente una condanna a morte per qualsiasi soluzione che richiede al processo di morte di fare qualcosa.

Guarda le ipotesi, in particolare che nessun processo rimanga indefinitamente nella sezione critica (che certamente include anche andare via). Non penso che ci sia un modo per risolvere quel problema generale con qualsiasi meccanismo di sincronizzazione.

$n$