რა არის starvation (შიმშილი) მრავალპოტონული კონტექსტში?

ერთი ან მეტი goroutine (თხილი, პროცესები) არასდროს იღებს წვდომას რესურსზე (მაგალითად, mutex, არხი), რომელიც მათ სჭირდებათ განაგრძოს შესრულება, მაშინ როდესაც სხვა goroutine-ები მუდმივად იღებენ წვდომას ამ რესურსზე. ეს ხდება უსამართლო დაგეგმვის ან არასასურველი სინქრონიზაციის მექანიზმების, როგორიცაა პრიორიტეტები ან ზედმეტად შენარჩუნებული ბლოკირებები გამო.

მაგალითი:

package main

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

var (
	mu      sync.Mutex
	counter int
)

func worker(id int) {
	for {
		mu.Lock() // რესურსის (counter) დაცვა
		// აქ შეიძლება მოხდეს შიმშილი, თუ სხვა goroutine-ები
		// მუდმივად იჭერენ mutex-ს და დიდხანს ინახავენ.
		counter++
		fmt.Printf("მუშაკი %d გაზარდა გამოთვლილი %d-მდე\n", id, counter)
		time.Sleep(10 * time.Millisecond) // სამუშაოს იმიტაცია
		mu.Unlock()
		// მცირე შეფერხების დამატება, რათა დაგეგმავმა შეძლოს კონტექსტის შეცვლა
		time.Sleep(1 * time.Millisecond)
	}
}

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

	// პროგრამა უსასრულოდ იმუშავებს,
	// მაგრამ ზოგიერთი მუშაკი შეიძლება შიმშილობა განიცადოს
	// დაგეგმავზე და დატვირთვაზე დამოკიდებული.
	select {}
}

შიმშილის მინიმიზაციისთვის გამოიყენება:

• სამართლიანი ბლოკირებები (fair locks): გარანტირებულია, რომ ნაკადები მიიღებენ წვდომას რესურსზე მოთხოვნის წესით.
• შემთხვევითობა: შემთხვევითობის შეტანა ნაკადების არჩევანში, რომელიც მიიღებს წვდომას რესურსზე.
• Timeouts: დროის შეზღუდვების დაყენება რესურსზე მოლოდინისთვის.
• პრიორიტეტების ინვერსიის თავიდან აცილება: მაღალი პრიორიტეტული პროცესი უნდა ელოდოს დაბალი პრიორიტეტული პროცესის დასრულებას.

Go-ის სტანდარტული mutex-ები არ გარანტირებენ სამართლიანობას, რაც შეიძლება გამოიწვიოს შიმშილობა გარკვეულ პირობებში.