როგორ არის განხორციელებული კონკურენციისა და სინქრონიზაციის მოდელი ენის Go-ში?

Go ენის კონკურენტობა განხორციელებულია მსუბუქი ნაკადების — goroutine-ების საშუალებით. Goroutine-ები იწყება საკვანძო სიტყვა go-ს გამოყენებით და მუშაობს პარალელურად, ამ დროს Go-ის runtime-ი თვითონ მართავს მათი დაგეგმვას.

Goroutine-ების შორის სინქრონიზაციისა და მონაცემთა გაცვლისთვის გამოიყენება რამდენიმე მექანიზმი:

• კანალები (channels) — უზრუნველყოფს უსაფრთხო მონაცემთა გადაცემას goroutine-ებს შორის და სინქრონიზაციას. კანალებს შეიძლება შევხედოთ როგორც რიგებს, რომლებიც ბლოკავენ გამგზავნს, თუ ისინი სავსეა, და მიმღებს, თუ ისინი ცარიელია.

• sync პაკეტი — შეიცავს სინქრონიზაციის primitives-ებს, როგორიცაა mutex-ები (sync.Mutex), პირობითი ცვლადები (sync.Cond), მოლოდინის ჯგუფები (sync.WaitGroup) და სხვა.

Goroutine-ებისა და კანალების გამოყენების მაგალითი:

package main
import (
    "fmt"
    "time"
)

func worker(id int, ch chan string) {
    time.Sleep(time.Second)
    ch <- fmt.Sprintf("მუშაკი %d დასრულდა", id)
}

func main() {
    ch := make(chan string)
    for i := 1; i <= 3; i++ {
        go worker(i, ch)
    }
    for i := 1; i <= 3; i++ {
        msg := <-ch
        fmt.Println(msg)
    }
}

აქ სამი goroutine პარალელურად მუშაობს, და კანალი გამოიყენება თითოეულის შედეგების მისაღებად.