Ce este foametea (starvation) în contextul programării multi-thread?

Stare în care unul sau mai multe goroutines (fire, procese) nu accesează niciodată o resursă (de exemplu, un mutex, un canal) de care au nevoie pentru a continua execuția, în timp ce altele au acces constant la această resursă. Acest lucru se întâmplă din cauza planificării nedrepte sau a mecanismelor de sincronizare ineficiente, cum ar fi prioritățile sau blocările excesive.

Exemplu:

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	mu      sync.Mutex
	counter int
)

func worker(id int) {
	for {
		mu.Lock() // Protejăm resursa (counter)
		// Aici poate apărea foamete dacă alte goroutines
		// captură constant mutexul și îl mențin mult timp.
		counter++
		fmt.Printf("Lucrător %d a crescut contorul la %d\n", id, counter)
		time.Sleep(10 * time.Millisecond) // Simulare de muncă
		mu.Unlock()
		// Adăugăm o întârziere mică pentru ca planificatorul să poată schimba contextul
		time.Sleep(1 * time.Millisecond)
	}
}

func main() {
	for i := 0; i < 5; i++ {
		go worker(i)
	}

	// Programul va rula indefinit,
	// dar unii lucrători pot suferi de foamete
	// în funcție de planificator și de sarcină.
	select {}
}

Pentru a minimiza foametea, se aplică:

• Blocări echitabile (fair locks): Asigură că firele de execuție obțin acces la resursă în ordinea solicitării.
• Randomizare: Introducerea aleatorietății în alegerea firului de execuție care va avea acces la resursă.
• Timeout-uri: Stabilirea limitelor de timp pentru a aștepta resursa.
• Evitarea inversiunii de prioritate: Evitarea situațiilor în care un proces cu prioritate înaltă așteaptă pe unul cu prioritate scăzută.

În Go, mutexurile standard nu garantează echitatea, ceea ce poate duce la foamete în anumite condiții.