Как планировщик Go (Go Scheduler) обрабатывает блокирующие системные вызовы, например, сетевые запросы?

Планировщик Go спроектирован так, чтобы эффективно обрабатывать большое количество одновременно выполняющихся горутин, особенно при работе с I/O-операциями (ввод-вывод), такими как сетевые запросы или чтение файлов. Он использует модель M:P:G.

• G: Goroutine (горутина) — легковесный поток, управляемый Go.
• M: Machine (машина) — поток операционной системы.
• P: Processor (процессор) — контекст для выполнения горутин. У каждого P есть своя очередь готовых к выполнению горутин.

Процесс обработки блокирующего сетевого вызова:

Когда горутина (G) инициирует блокирующий системный вызов (например, http.Get), происходит следующее:

1. 
   

   Перехват вызова: Runtime Go перехватывает этот вызов. Вместо того чтобы напрямую заблокировать поток ОС (M), он использует интегрированный сетевой поллер (network poller).

   
   
2. 
   

   Парковка горутины: Горутина (G) переводится в состояние ожидания. Сетевой поллер запоминает, какая горутина ожидает ответа по этому сетевому соединению.

   
   
3. 
   

   Освобождение потока: Поток ОС (M), на котором выполнялась горутина, отсоединяется от своего процессора (P). Но сам процессор (P) и его очередь горутин не простаивают.

   
   
4. 
   

   Выполнение другой работы: Планировщик немедленно берет другой свободный или создает новый поток (M) и привязывает его к этому же процессору (P). Этот новый M начинает выполнять другую горутину из очереди P. Таким образом, CPU не простаивает, пока первая горутина ждет ответа от сети.

   
   
5. 
   

   Пробуждение горутины: Когда сетевой поллер получает сигнал от ОС о том, что данные по сетевому соединению готовы (например, пришел ответ на HTTP-запрос), он находит ожидающую горутину (G) и переводит ее обратно в состояние "готова к выполнению", помещая ее в одну из очередей P.

   
   
6. 
   

   Возобновление: При следующей возможности планировщик назначит эту горутину для выполнения на одном из потоков (M).

   
   

go func() {
    // 1. Горутина инициирует блокирующий вызов
    resp, err := http.Get("https://example.com") 
    // 2. В этой точке горутина "паркуется", а поток ОС (M) 
    //    начинает выполнять другую работу. CPU не простаивает.

    // 3. Когда ответ получен, горутина становится в очередь 
    //    и в конечном итоге продолжает выполнение с этой строки.
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
}()

Вывод: Эта модель позволяет Go эффективно управлять десятками тысяч горутин на небольшом количестве потоков ОС, делая его идеальным для написания высоконагруженных сетевых сервисов. Программист пишет простой синхронный код, а планировщик асинхронно и неблокирующе выполняет его "под капотом".