Mida tuleb meeles pidada, töötades mutexidega Go-s?

Kui töötate sync.Mutex-iga Go keeles, on oluline meeles pidada järgmist:

• Lukustamine ja vabastamine: Mutexi tuleb kindlasti lukustada (Lock()) enne jagatud andmetele juurdepääsu ja vabastada (Unlock()) pärast nende töö lõpetamist. Kasutades defer mu.Unlock() kohe pärast mu.Lock() on hea tava, mis aitab vältida unustatud vabastamist.
• Sünkroniseerimise garantii: Mutex võimaldab eksklusiivset juurdepääsu ressursile korraga ainult ühe gorutina poolt.
• "Lukustatud/vabastatud" olek: Korduv Lock()-i kutsumine juba lukustatud mutexi puhul blokeerib kutsuva gorutina kuni teise gorutina vabastab mutexi. Unlock()-i kutsumine vabastamata mutexil põhjustab jooksu ajal paanikaga.
• Ärge kopeerige mutexe: Struktuur sync.Mutex ei ole mõeldud kopeerimiseks pärast esmast kasutamist. Mutexi väärtuse edastamine funktsioonile või struktuuri kopeerimine, mis sisaldab mutexi, võib põhjustada vale sünkroniseerimise ja paanikaga.
• Deadlock (surnus): Tekib, kui kaks või enam gorutinat ootavad üksteiselt ressursi vabastamist. Tüüpiline stsenaarium: gorutin A lukustab R1 ressursi ja ootab R2, samal ajal kui gorutin B lukustab R2 ja ootab R1.
• Livelock (elav lukustus): Situatsioon, kus gorutinatid pidevalt muudavad oma olekut vastusena teiste tegevustele, kuid ei tee kasulikku tööd ega edene. See on harvem kui deadlock.
• Nälgimine: Situatsioon, kus üks või mitu gorutinat ei saa jagatud ressursile juurdepääsu, kuna teised gorutinad pidevalt seda kasutavad. Go mutexide puhul nälgimine ei ole garanteeritud.
• sync.RWMutex kasutamine lugemiseks/ kirjutamiseks: Kui enamik operatsioone on lugemine ja kirjutamine on haruldane, võib sync.RWMutex olla tõhusam. See võimaldab mitmel gorutinil lugeda samaaegselt, kuid kirjutamise ajal blokeerib nii lugemise kui ka teiste kirjutamistegevuste.
• Lühikesed lukustused: Püüdke hoida lukustused võimalikult lühikesed. Mida kauem mutex on lukus, seda suurem on tõenäosus, et teised gorutined ootavad, mis vähendab paralleelsust.
• Võistluste testimine: Kasutage -race lipu abil go test-i koostamisel ja käivitamisel, mis aitab avastada võistlusi, mis sageli tulenevad mutexide valest kasutamisest.

Näide defer kasutamisest:

import (
	"sync"
)

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

// Inc suurendab turvaliselt loendurit antud võtme jaoks.
func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()
	// Ootame vabastamist funktsiooni lõpus.
	defer c.mu.Unlock()
	c.v[key]++
}

// Value tagastab praeguse loenduri väärtuse antud võtme jaoks.
func (c *SafeCounter) Value(key string) int {
	c.mu.Lock()
	// Ootame vabastamist pärast väärtuse saamist.
	defer c.mu.Unlock()
	return c.v[key]
}