Краткий ответ

Вызов go f(x) вычисляет значение функции f и аргумент x в текущей горутине, после чего запускает новую горутину для выполнения вызова. Однако это не гарантирует, когда именно новая горутина начнёт выполняться и завершится ли она до продолжения текущей.

Исторический контекст

Горутины в Go предназначены для простого запуска независимых единиц работы, а планирование их выполнения передано рантайму. Такой подход избавляет разработчика от ручного управления потоками ОС в типичных сценариях.

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

Постановка проблемы

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

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

Подробное решение

В выражении go f(x) сначала вычисляются значение функции и все аргументы, включая x. Эти вычисления выполняются в вызывающей горутине. Затем создаётся новая горутина, которая выполняет вызов с уже вычисленными значениями.

Например:

package main

import "fmt"

func show(v int) {
	fmt.Println(v)
}

func main() {
	i := 10
	go show(i)
	i = 20
}

В show передаётся значение 10, потому что значение i вычисляется до запуска вызова в новой горутине. Последующее присваивание i = 20 не меняет уже переданный параметр v.

Это не означает, что любые данные копируются. Если аргументом является указатель, срез, карта или значение, содержащее ссылку на общую память, копируется соответствующее значение-ссылка, а доступ к объекту может оставаться совместным. Параллельная запись и чтение такой памяти без синхронизации может привести к гонке данных.

Порядок выполнения тела горутины относительно последующих инструкций вызывающей горутины не следует использовать как средство синхронизации. Если результат или завершение важны, применяют канал, sync.WaitGroup, context.Context для отмены или другой подходящий механизм.

Ситуация из практики

Сервис запускает обработку задания в фоне и передаёт ей идентификатор. Идентификатор вычисляется из текущего запроса до конструкции go, поэтому функция-обработчик получает стабильное значение даже при дальнейшем изменении локальной переменной.

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

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

Что кандидаты часто упускают

Дополнительный вопрос 1: меняет ли последующее присваивание локальной переменной значение параметра горутины?

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

Дополнительный вопрос 2: гарантирует ли go запуск функции до выполнения следующей инструкции?

Нет. go гарантирует запуск отдельного вызова в новой горутине, но не предоставляет порядка между телом этой горутины и последующим кодом вызывающей горутины. Если такой порядок нужен, его следует установить через канал или другой примитив синхронизации.

Дополнительный вопрос 3: где вычисляется функция-значение в конструкции с отложенным вызовом?

Для go функция-значение и аргументы вычисляются немедленно в текущей горутине, а выполняется вызов позже в новой. Это отличается от defer: там вызов также откладывается, но выполняется при выходе из текущей функции и не создаёт новую горутину.