What is starvation in the context of multithreading?

Starvation is a state where one or more goroutines (threads, processes) never gain access to a resource (such as a mutex or channel) that they need to continue execution, while other goroutines constantly access this resource. This occurs due to unfair scheduling or inefficient synchronization mechanisms, such as priorities or excessive lock holding.

Example:

package main

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

var (
	mu      sync.Mutex
	counter int
)

func worker(id int) {
	for {
		mu.Lock() // Protecting the resource (counter)
		// Starvation can occur here if other goroutines
		// constantly acquire and hold the mutex for a long time.
		counter++
		fmt.Printf("Worker %d increased counter to %d\n", id, counter)
		time.Sleep(10 * time.Millisecond) // Simulate work
		mu.Unlock()
		// Add a small delay to allow the scheduler to switch
		time.Sleep(1 * time.Millisecond)
	}
}

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

	// The program will run indefinitely,
	// but some workers may experience starvation
	// depending on the scheduler and load.
	select {}
}

To minimize starvation, the following are used:

• Fair locks: Guarantee that threads access the resource in the order of request.
• Randomness: Introduce randomness in selecting the thread that will access the resource.
• Timeouts: Set time limits for waiting for a resource.
• Priority inversion avoidance: Avoid situations where high-priority processes wait for low-priority ones.

In Go, standard mutexes do not guarantee fairness, which can lead to starvation under certain conditions.