В какой момент происходит переключение горутин

Переключение горутин в Go

В Go переключение горутин происходит не в фиксированные моменты, а по определенным событиям или условиям, которые управляются планировщиком (scheduler). Планировщик Go — это часть runtime, которая координирует выполнение множества горутин на ограниченном количестве потоков ОС (M).

Основные моменты переключения горутин

Переключение (или context switch) происходит, когда текущая выполняющаяся горутина переходит в состояние, позволяющее планировщику выбрать другую горутин для выполнения. Ключевые события:

1. Системные вызовы (syscalls)
   Когда горутина выполняет системный вызов (например, чтение файла, сетевые операции), она может блокироваться. Планировщик может приостановить эту горутин и переключиться на другую, чтобы эффективно использовать ресурсы.

   // Пример: системный вызов при чтении файла
   data, err := os.ReadFile("file.txt") // Здесь может произойти переключение
   

2. Операции с каналами (channel operations)
   Если горутина пытается читать из пустого канала или писать в заполненный канал, она блокируется, и планировщик переключается на другую горутин.

   ch := make(chan int, 1)
   ch <- 42          // Письмо — если канал заполнен, горутина блокируется
   value := <-ch     // Чтение — если канал пуст, горутина блокируется
   

3. Работа с синхронизациями (mutexes, waitgroups)
   При использовании sync.Mutex, sync.WaitGroup или других механизмов синхронизации, если горутина блокируется (например, пытается захватить уже занятый мьютекс), происходит переключение.

   var mu sync.Mutex
   mu.Lock()         // Если мьютекс занят, горутина блокируется
   // Критическая секция
   mu.Unlock()
   

4. Вызов runtime.Gosched()
   Эта функция явно уступает процессорное время, позволяя планировщику переключиться на другую горутин. Используется для кооперативной многозадачности.

   runtime.Gosched() // Планировщик может переключиться на другую горутин
   

5. Сетевые операции и I/O
   В современных версиях Go сетевые операции интегрированы с планировщиком через netpoller. Когда горутина ожидает сетевого события (например, ответа от сервера), она блокируется, и планировщик переключает контекст.

6. Завершение горутины
   Когда горутина завершает свое выполнение, планировщик автоматически переключается на следующую доступную горутин.

Как работает планировщик

Планировщик Go использует кооперативную модель с элементами вытеснения. Он не прерывает горутин произвольно (как в вытесняющей многозадачности), но может "вытеснить" горутин, если она выполнялась слишком долго (например, более 10ms), чтобы обеспечить справедливость.

Ключевые компоненты планировщика:

• G: Горутина (goroutine)
• M: Поток ОС (machine)
• P: Процессор (processor) — логический контекст для выполнения горутин

Когда горутина блокируется, M (поток ОС) может быть отделен от P и использоваться для другой работы, а P может выбрать другую горутин для выполнения.

Пример переключения в коде

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int)

    go func() {
        time.Sleep(1 * time.Second) // Горутина блокируется на sleep
        ch <- 42                    // Планировщик может переключиться здесь
    }()

    fmt.Println("Ожидание данных...")
    value := <-ch // Здесь основная горутина блокируется, ожидая данные
    fmt.Println("Получено:", value)
}

В этом примере:

• Горутина main блокируется при чтении из канала ch, что вызывает переключение.
• Горутина go func() блокируется на time.Sleep, также вызывая возможное переключение.

Итог

Переключение горутин происходит неявно при блокировках (системные вызовы, каналы, синхронизация) или явно через runtime.Gosched(). Планировщик Go эффективно управляет тысячами горутин, переключая контекст только когда это необходимо, что снижает накладные расходы и обеспечивает высокую производительность параллельных программ. Это одна из ключевых особенностей, делающих Go эффективным для concurrent-программирования.