В каких ситуациях горутины попадают в глобальную очередь

Горутины и глобальная очередь в Go

В Go горутины (goroutines) — это легковесные потоки, управляемые планировщиком (scheduler) внутри Go runtime. Планировщик распределяет горутины между локальными очередями (local runqueues), связанными с логическими процессорами (GOMAXPROCS), и глобальной очередью (global runqueue). Горутины попадают в глобальную очередь в нескольких специфических ситуациях.

Основные ситуации попадания горутины в глобальную очередь

1. Создание новой горутины с помощью go

Когда горутина создаётся (например, go func() { ... }()), планировщик пытается поместить её в локальную очередь текущего логического процессора (P). Однако, если локальная очередь переполнена (обычно содержит более 256 горутин), новая горутина отправляется в глобальную очередь.

func main() {
    for i := 0; i < 1000; i++ {
        go func(id int) {
            // Лёгкая горутина
        }(i)
    }
    // При большом числе создаваемых горутин часть попадет в глобальную очередь
}

2. Возвращение горутины из системного вызова или блокирующей операции

Когда горутина выполняет системный вызов (например, чтение файла, сетевые операции) или блокируется на операции типа channel receive, она может быть перемещена из локальной очереди в глобальную очередь после завершения блокировки. Это связано с тем, что во время блокировки логический процессор (P) освобождается для других горутин, а когда горутина готовится к повторному выполнению, она часто помещается в глобальную очередь для балансировки нагрузки.

3. Балансировка нагрузки (work stealing)

Планировщик Go использует механизм work stealing для распределения нагрузки между логическими процессорами. Если логический процессор (P) обнаруживает, что его локальная очередь пуста, он:

• Проверяет глобальную очередь.
• Проверяет локальные очереди других процессоров (ворует горутины). Горутины, которые были перемещены из других локальных очередей в процессе балансировки, временно могут находиться в глобальной очереди, но этот механизм скорее связан с взятием горутин из глобальной очереди, а не с помещением.

4. Завершение горутины и передача контекста

Когда горутина завершает выполнение, планировщик может решить переместить некоторые горутины из локальной очереди в глобальную для оптимизации распределения ресурсов, особенно если наблюдается дисбаланс нагрузки.

Внутренняя структура планировщика

Логический процессор (P) в Go имеет ограниченную локальную очередь (обычно размер 256). Планировщик управляет горутинами согласно этим ограничениям:

// Псевдо-код из runtime Go (концептуальный)
func schedule() {
    // Если локальная очередь переполнена, поместить в глобальную
    if len(localQueue) > 256 {
        globalQueue.Push(newGoroutine)
    }
}

Практический пример с переполнением локальной очереди

package main

import (
    "fmt"
    "time"
)

func main() {
    // Увеличиваем количество горутин для демонстрации
    for i := 0; i < ล000; i++ { // Значительно больше 256
        go worker(i)
    }
    time.Sleep(2 * time.Second)
}

func worker(id int) {
    fmt.Printf("Горутина %d запущена\n", id)
}

В этом примере часть горутин неизбежно попадает в глобальную очередь из-за переполнения локальных очередей логических процессоров.

Итог

Горутины попадают в глобальную очередь в случаях:

• Переполнения локальной очереди логического процессора при создании горутин.
• Возвращения из системного вызова или блокирующего состояния (например, I/O, channel operations).
• Балансировки нагрузки между логическими процессорами (work stealing), хотя это скорее механизм извлечения из глобальной очереди.
• Решения планировщика для оптимизации распределения при завершении горутин или дисбалансе.

Глобальная очередь служит буфером и механизмом балансировки, позволяя планировщику эффективно распределять работу между всеми доступными логическими процессорами, что особенно важно в высоконагруженных приложениях с тысячами горутин.