რა იწვევს goroutine-ის გაჟონვებს და როგორ თავსდებით მათ?

Question

Accepted Answer

**Goroutine leak** არის goroutine, რომელიც არასოდეს წყდება — ის რჩება დაბლოკილი ან სამუდამოდ გაშვებული, კვლავდება მეხსიერება (და ინახავს მის მიერ მითითებული ობიექტების სიცოცხლე) პროგრამის მთელი ხანგრძლივობის განმავლობაში. ვინაიდან goroutine-ები იაფი სტარტის জন্য, მათი გაჟონვება ადვილია, და გაჟონვებები ჩუმად დაგროვდება, სანამ სერვისი არ დაიკნინება ან მეხსიერება არ ამოიწურება.

## მიზეზი 1: დაბლოკილი channel-ზე გამომთხევის/მიმღებ გარეშე

```go
// ❌ LEAK — this goroutine blocks forever waiting to send
func leak() {
    ch := make(chan int)   // unbuffered
    go func() {
        ch <- 42           // blocks forever — NOBODY ever receives
    }()                     // the goroutine is stuck, never exits
    // function returns without reading ch → the goroutine leaks
}
```

Goroutine, რომელიც დაბლოკილია channel-ის გაგზავნისას/მიღებისას, რომელიც არასოდეს დასრულდება, **სამუდამოდ** ელოდება — ის არ გარკვეულდება ნაგალი კოლექციის მიერ, რადგან ის ტექნიკურად ჯერ კიდევ "გაშვებული" იმყოფება.

## მიზეზი 2: უარი გამოხმელი/შესრულებული სიგნალის გარეშე

```go
// ❌ LEAK — a goroutine in an infinite loop with no way to stop
func worker(jobs <-chan int) {
    for {
        job := <-jobs      // blocks forever if jobs is never closed and stops sending
        process(job)
    }                       // no exit condition — leaks when no longer needed
}
```

## პრევენცია 1: გამოიყენეთ context გაუქმებისთვის

```go
// ✅ the goroutine can be told to stop
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():       // cancellation signal → exit cleanly
            return                // the goroutine terminates, no leak
        }
    }
}
// caller: ctx, cancel := context.WithCancel(...); defer cancel()
```

ითითოეული ხანგრძლივი goroutine-ს მისაღები გაუქმებული გზა (`<-ctx.Done()`) არის ძირითადი თავდაცვა — ის უზრუნველყოფს goroutine-ების დამთავრებას, როდესაც მათი მუშაობა აღარ არის საჭირო.

## პრევენცია 2: გამოიყენეთ buffered channel-ები ან უზრუნველყოფილი მიმღებები

```go
// ✅ ensure a receiver exists, or use a buffered channel so the send doesn't block
ch := make(chan int, 1)   // buffered → the send completes even if no one receives yet
go func() { ch <- 42 }()   // doesn't block
```

## პრევენცია 3: ყოველთვის დახუჭეთ channel-ები / გაწმენდეთ ისინი სათანადოდ

```go
// ✅ close channels so range loops terminate
go func() {
    defer close(results)    // signal completion → for-range over results ends
    for _, job := range jobs { results <- process(job) }
}()
```

## გაჟონვების აღმოჩენა

```go
runtime.NumGoroutine()         // monitor the goroutine count — steady growth = leak
import _ "net/http/pprof"      // pprof exposes goroutine stacks (/debug/pprof/goroutine)
// the goleak library asserts no leaked goroutines in tests
```

`runtime.NumGoroutine()` -ის მონიტორინგი (სტაბილურად აღმავალი რაოდენობა სიგნალიზებს გაჟონვებას), goroutine-ის დამპი ნახვა `pprof`-ის მাშინებლად და `goleak` -ის გამოყენება ტესტებში არის ძირითადი აღმოჩენის ხელსაწყოები.

## რატომ მნიშვნელოვანია

Goroutine-ის გაჟონვებები წარმოადგენს წარმოებაში Go სერვისების ერთ-ერთი ყველაზე გავრცელებული და თაკი პრობლემა.

ვინაიდან goroutine-ები არ არის ისე იაფი გაშვებისთვის, დეველოპერები უფასოდ აქვთ მათ შექმნა — მაგრამ goroutine დაბლოკილი სამუდამოდ (channel-ზე სხვა მხარის გარეშე, ან უსასრულო ციკლში გაუქმების გარეშე) **არასოდეს წყდება და არასოდეს ხელმისაწვდომი მეხსიერება** (მათ შორის ყველაფერი, რაც იგი მითითებული აქვს).

ხანგრძლივი სერვერი, ეს გაჟონვებები ჩუმად აგროვებდა, თანდათანობით ხმელიკიდან მეხსიერება, სანამ სერვისი არ დაიკნინება ან არ ჩავარდება — და ისინი ძნელი აღმოსაჩენია, რადგან დაუყოვნებელი შეცდომა არ არსებობს.

მიზეზების გაცნობა (დაბლოკილი channel-ის ოპერაციები, გაუქმების არარსებობა) და პრევენციები (**context-ზე დაფუძნებული გაუქმება** ძირითადი თავდაცვა, channel-ის სათანადო დახურვა, buffered channel-ები, მიმღებების უზრუნველყოფა) აუცილებელია საიმედო კონკურენტული Go-ს დასაწერად.

მონიტორინგის ხელსაწყოების ცოდნა (`runtime.NumGoroutine`, pprof, goleak) თანაბრად მნიშვნელოვანია.

ეს გადამწყვეტი, ხშირად გამოცდილი თემა, რომელიც ხელს უწყობს დეველოპერებმა, რომელმაც შეუძლია წარმოებაში მიმდებარე Go-ს დაწერა იმ მოწოდებებისგან, რომელთაც აღმოჩნდა კოდი, რომელიც გაჟონვება ხდება მძიმე დატვირთვის მოწმენებისას.