Wat is starvation (honger) in de context van multithreading?

Status waarin een of meer goroutines (draad, processen) nooit toegang krijgen tot een resource (bijvoorbeeld een mutex, kanaal) die ze nodig hebben om verder te gaan, terwijl andere goroutines voortdurend toegang krijgen tot die resource. Dit gebeurt door oneerlijke planning of inefficiënte synchronisatie-mechanismen, zoals prioriteiten of overmatig vasthouden van blokkades.

Voorbeeld:

package main

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

var (
	mu      sync.Mutex
	counter int
)

func worker(id int) {
	for {
		mu.Lock() // Resource (counter) beveiligen
		// Hier kan hongersnood ontstaan als andere goroutines
		// constant de mutex pakken en lang vasthouden.
		counter++
		fmt.Printf("Werker %d heeft teller verhoogd tot %d\n", id, counter)
		time.Sleep(10 * time.Millisecond) // Werk simulatie
		mu.Unlock()
		// Voeg een kleine vertraging toe zodat de scheduler kan wisselen
		time.Sleep(1 * time.Millisecond)
	}
}

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

	// Het programma draait oneindig,
	// maar sommige workers kunnen hongersnood ervaren
	// afhankelijk van de scheduler en de belasting.
	select {}
}

Om hongersnood te minimaliseren worden toegepast:

• Eerlijke locks (fair locks): Garanderen dat threads toegang krijgen tot de resource in de volgorde van aanvraag.
• Willekeurigheid: Invoeren van willekeur bij de selectie van de thread die toegang krijgt tot de resource.
• Timeouts: Instellen van tijdslimieten voor het wachten op een resource.
• Prioriteitsinversie voorkomen: Voorkomen dat een hoogprioriteitsproces wacht op een laagprioriteitsproces.

In Go garanderen standaard mutexes geen eerlijkheid, wat kan leiden tot hongersnood onder bepaalde omstandigheden.