რა იცით sync.Map პაკეტზე?

პაკეტი sync.Map უზრუნველყოფს პარალელურად უსაფრთხო ჰეშ-ცხრილს. იგი ოპტიმიზირებულია შემთხვევებისთვის, როდესაც გასაღებები ძირითადად იკითხება და იშვიათად იწერება.

ძირითადი მახასიათებლები:

• პარალელური უსაფრთხოება: უზრუნველყოფს უსაფრთხო წვდომას რამდენიმე გორუტინიდან აშლილ ბლოკირებებთან გარეშე.
• ოპტიმიზირებული წაკითხვისთვის: თითოეული გასაღებისთვის პირველი წაკითხვისას ის კეშში ინახება მხოლოდ წაკითხვისთვის. შემდეგი წაკითხვები ამ კეშიდან ბლოკირებას არ საჭიროებს.
• დინამიური წაშლა: წაშლილი ელემენტები პირველ ეტაპზე მონიშნულია როგორც წაშლილი, ხოლო რეალური წაშლა ხდება გარკვეული პირობებით, რათა მინიმუმამდე დაიყვეს წერის ბლოკირებები.
• Len() მეთოდი არ არის: Len() მეთოდის მხარდაჭერა გახდის პარალელურად უსაფრთხო განხორციელებას რთულ და ძვირადღირებულ.
• არ არის შესაფერისი მუდმივად ცვალებადი მონაცემებისთვის: ხშირი წერებისა და წაშლების დროს, ის შეიძლება იყოს ნაკლებად ეფექტიანი, ვიდრე ჩვეულებრივი map-ის გამოყენება sync.Mutex ან sync.RWMutex-თან ერთად.

ძირითადი მეთოდები:

• Load(key any) (value any, ok bool): იტვირთება დაკავშირებული მნიშვნელობა გასაღებთან. თუ გასაღები არ არსებობს, აბრუნებს false.
• Store(key, value any): ინახავს მნიშვნელობას გასაღებთან. შეიძლება გამოყენებულ იქნას დამატებისა ან განახლებისთვის.
• LoadOrStore(key any, value any) (actual any, loaded bool): იტვირთება დაკავშირებული მნიშვნელობა, თუ ის უკვე არსებობს. წინააღმდეგ შემთხვევაში, ინახება მითითებული მნიშვნელობა. აბრუნებს ფაქტობრივ მნიშვნელობას და ფლაგს, რომელიც მიუთითებს, იყო თუ არა მნიშვნელობა იტვირთული (true) ან შენახული (false).
• Delete(key any): წაშლის მნიშვნელობას გასაღებთან.
• Range(f func(key, value any) bool): იტერაცია ხდება მეპის ელემენტებზე ნებისმიერი წესით. ფუნქცია f იძახება თითოეულ გასაღ-შესაფრისთვის. თუ f აბრუნებს false, იტერაცია შეჩერდება.

გამოყენების მაგალითი:

import "sync"

var m sync.Map

func process(key string, value int) {
	m.Store(key, value)

	v, ok := m.Load(key)
	if ok {
		// ვიყენებთ v
	}

	m.Range(func(key, value any) bool {
		// ვმუშაობთ ელემენტებზე
		return true // ვაგრძელებთ იტერაციას
	})
}

საერთო ჯამში, sync.Map კარგი არჩევანია, როდესაც პარალელური წაკითხვები მნიშვნელოვნად აღემატება წერებს და წაშლებს. წინააღმდეგ შემთხვევაში, map-ის გამოყენება sync.Mutex ან sync.RWMutex-თან ერთად შეიძლება იყოს უფრო შესაბამისი.