Hogyan lehet elkerülni a kölcsönös zárolási (deadlock) helyzetet egy Go programban?

A kölcsönös zárolás Go-ban leggyakrabban mutexek és csatornák helytelen használata miatt fordul elő. Az alábbi módszerekkel lehet elkerülni:

• Rendezett mutex-elfogás: Több mutex elfogadásakor mindig ugyanabban a sorrendben tegyük ezt meg minden gorutinnál.
• Időkorlátok zárolásokhoz: Használjunk időkorlátos kontextusokat zárolások vagy csatornákból való fogadás közben, hogy elkerüljük a végtelen várakozást.
• Nem pufferelt csatornák: Értse meg, hogy a nem pufferelt csatornák mind a küldő, mind a fogadó fél részéről folytatást igényelnek. Helytelen használatuk zároláshoz vezethet.
• Pufferelt csatornák: Válassza meg helyesen a csatorna pufferének méretét. A túl kicsi buffer zároláshoz vezethet, ha a küldők és fogadók nem szinkronizáltak.
• select használata: Több csatornával való munka során használja a select operátort default ággal vagy időkorláttal, hogy ne blokkoljon egy csatornál.
• Kód elemzése: Használjon statikus elemző eszközöket (go vet, staticcheck) és versenyfeltételeket felismerő eszközöket (go run -race), amelyek segítenek az esetleges kölcsönös zárolási helyek azonosításában.
• Erőforrás hierarchia: Ha az erőforrások hierarchiával rendelkeznek, fogja őket felülről lefelé.
• Ciklikus függőségek elkerülése: Ne hozzon létre olyan helyzeteket, ahol az A gorutina egy B által foglalt erőforrást vár, miközben B egy A által foglalt erőforrást vár.

Példa a select és időkorlát használatára:

import (
	"context"
	"time"
)

func példa(ch chan int) {
	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
	defer cancel()

	select {
	case val := <-ch:
		// Érték feldolgozása
		_ = val
	case <-ctx.Done():
		// Időkorlát elérve
	}
}