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

При создании значения метода получатель вычисляется и сохраняется сразу. Для метода со значимым получателем сохраняется копия значения, а для метода с указательным получателем — копия указателя.

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

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

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

Такой подход позволяет передавать поведение вместе с контекстом объекта без ручного создания отдельной функции-замыкания. Одновременно он требует понимать момент фиксации получателя, иначе легко получить вызов не для того состояния объекта, которое ожидалось.

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

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

Ошибка особенно заметна при различии между значимым и указательным получателем. В первом случае метод может работать с копией структуры, а во втором — с объектом по сохранённому адресу; это приводит к разным результатам и разным требованиям к синхронизации.

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

При выражении вида «значение метода» Go сначала вычисляет получатель, а затем формирует вызываемое значение, в котором этот получатель уже сохранён.

Для метода со значимым получателем сохраняется копия структуры. Изменение исходной структуры после создания значения метода не повлияет на эту копию. Для метода с указательным получателем сохраняется значение указателя: переназначение исходного указателя не меняет сохранённый указатель, но изменения самого объекта по этому адресу видны.

Минимальный пример:

package main

import "fmt"

type Counter struct{ n int }
func (c Counter) Value() int { return c.n }
func (c *Counter) Add()      { c.n++ }

func main() {
    c := Counter{n: 1}
    value := c.Value
    add := c.Add
    c.n = 10
    add()
    fmt.Println(value(), c.n)
}

Результат — 1 11: value получил копию структуры в момент создания, а add сохранил указатель на c и изменил тот же объект.

Важно отличать это от метода-выражения. Метод-выражение само по себе не фиксирует конкретный объект: получатель передаётся отдельным аргументом при каждом вызове. Значение метода, напротив, уже связано с определённым получателем.

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

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

Сервис формирует callback для очереди задач и сохраняет метод обработчика. Позже переменная, содержащая указатель на обработчик, переназначается на новый объект.

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

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

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

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

Что произойдёт, если указатель-получатель переназначить после создания значения метода?

Сохранённое значение метода продолжит использовать старый указатель. При создании значения метода копируется само значение указателя, а не переменная, в которой этот указатель хранится. Поэтому переназначение исходной переменной не переключает уже созданный callback на новый объект.

Всегда ли значимый получатель полностью изолирован от изменений исходного объекта?

Изолируется копия структуры, но не обязательно данные, на которые ссылаются её поля. Если структура содержит срез, map, указатель или интерфейс со ссылочным внутри значением, копирование структуры может оставить общие underlying-данные. Поэтому значение метода с копируемым получателем не гарантирует глубокой копии всего графа данных.

Что происходит с локальной переменной, если значение метода с указательным получателем возвращается наружу?

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