Ինչ պետք է հիշել, աշխատելիս mutex-ների հետ Go-ում?

Ի աշխատելիս մյուտեքսների (sync.Mutex) հետ Go- ում կարևոր է հիշել հետևյալը:

• Ապահովել և ազատել: Մյուտեքսը պարտադիր է փակել (Lock()) նախքան բաժանվող տվյալներին մուտք գործելը և ազատել (Unlock()) աշխատանքը ավարտելուց հետո: Օգտագործել defer mu.Unlock() անմիջապես հետո mu.Lock() -ը լավ պրակտիկա է, որը օգնում է կանխել մոռացության պատճառով բաց թողնված ազատումը:
• Սինխրոնիզացիայի արտոնագիր: Մյուտեքսը ապահովում է բացառիկ մուտք դեպի ռեսուրս՝ միաժամանակ միայն մեկ գորուտին:
• "Փակ/բաց" վիճակ: Վերահրապարակման Lock() -ը արդեն փակ մյուտեքսի վրա կբլոկավորի հորդին, մինչև որ այլ գորուտին բացի այն: Unlock() -ը բաց մյուտեքսի վրա կհանգեցնի փլուզման:
• Մի պատճենեք մյուտեքսները: sync.Mutex կառուցվածքը նախատեսված չէ պատճենելու համար առաջին օգտագործումից հետո: Մյուտեքսը արժեքով փոխանցելը կամ պատճենելը կարող է հանգեցնել սխալ սինխրոնիզացիայի և փլուզման:
• Deadlock (կապ): Երբ երկու կամ ավելի գորուտին սպասում են միմյանց, որպեսզի ազատեն ռեսուրսները: Տիպիկ սցենար՝ գորուտին A փակել է R1 ռեսուրսը և սպասում R2 -ին, իսկ գորուտին B փակել է R2 և սպասում R1 -ին:
• Livelock (ապրելակերպի կապ): Երբ գորուտիները մշտապես փոխում են իրենց վիճակը միմյանց գործողությունների պատասխանով, բայց չեն կատարում օգտակար աշխատանք և չեն առաջանում առաջ:
• Հացթուկ (գլադ): Երբ մի կամ մի քանի գորուտիներ չեն կարող մուտք գործել բաժանվող ռեսուրս՝ այն մշտապես բռնագրաված մյուս գորուտիների կողմից: Go մյուտեքսներում հացթուկը չի երաշխավորվում:
• Օգտագործել sync.RWMutex ընթերցանության/գրության համար: Եթե շատ գործողություններ — ընթերցում, իսկ գրառումը հազվագյուտ է, sync.RWMutex -ը կարող է լինել ավելի արդյունավետ: Այն թույլ է տալիս միաժամանակ մի քանի գորուտիների ընթերցել, բայց գրառման ժամանակ բլոկավորում է ինչպես ընթերցումը, այնպես էլ մյուս գրառումները:
• Կարճ բլոկավորումներ: Փորձեք պահել բլոկավորումները հնարավորինս կարճ: Որքան երկար է մյուտեքսը փակ, այնքան մեծ է հավանականությունը, որ մյուս գորուտիները կսպասեն, ինչը նվազեցնում է համաժամանակությունը:
• Թեստավորում մրցակցությունների համար: Օգտագործեք -race նշանը go test -ի ժամանակ, որը օգնում է հայտնաբերել մրցակցություններ՝ հաճախ սխալ մյուտեքսների օգտագործման պատճառով:

Նմուշ defer -ի օգտագործման:

import (
	"sync"
)

type SafeCounter struct {
	mu sync.Mutex
	v  map[string]int
}

// Inc անվտանգ կերպով ավելացնում է հաշվողը նշված բանալիին:
func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()
	// Դադարեցնում ենք բաց թողնելը՝ ֆունկցիայի ավարտին:
	defer c.mu.Unlock()
	c.v[key]++
}

// Value վերադարձնում է ընթացիկ արժեքը նշված բանալիի համար:
func (c *SafeCounter) Value(key string) int {
	c.mu.Lock()
	// Դադարեցնում ենք բաց թողնելը՝ արժեք ստանալուց հետո:
	defer c.mu.Unlock()
	return c.v[key]
}