О себе

Привет! Я Артур Давыдов, бэкенд разработчик на Go. В этой статье хочу рассмотреть поведение defer более детально. Надеюсь, что статья будет полезна.

Введение

Defer это мощный инструмент в Go. Его можно (с огромной натяжкой) сравнить с деструкторами С++ или Finalizer в Dart, но происходит все действо в пределах стека одной функции. И этих вызовов может быть несколько

Это база

Defer в Go перемещает вызов функции в стэк (LIFO очередь) отложенных вызовов. Другими словами, функции в defer будут завершены при закрытии стека основной, относительно запуска defer, функции.

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

Конструкции c defer встречаются в Go настолько же часто (субъективное мнение и наблюдения автора), как и набившие оскомину if err != nil.

func AbstractFunction() error {
  // Тут могло быть ваше соединение с чем угодно
	f, err := os.OpenFile("zdravcity.txt", os.O_RDWR, 0777)
	if err != nil {
		return fmt.Errorf("Abstract function(Open file): %w", err)
	}
    
	defer f.Close()

  /*
  Какая-то логика. Тут файл еще открыт. 
*/

	return nil
}

Анонимка или в одну строчку?

Конечно, этот вопрос не касается defer непосредственно, однако, тут можно споткнуться особенно на собесах.

Что такое анонимная функция в Go?

Анонимная функция в Golang — это функция, у которой нет имени. Ее можно определить непосредственно там, где она нужна, без объявления отдельной именованной функции

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

Для вызова функции, в defer помещается указатель на функцию.

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

func main() {
	fmt.Printf("0x%x\n", reflect.ValueOf(func() {}).Pointer()) // Даже у такой функции есть указатель
}

А что будет, если передавать функцию с аргументами?
Go подставит значения переменных в вызываемую функцию и отложит ее выполнение на завершение основной функции (относительно defer).

Таким образом, вы спокойно можете понять разницу в этих двух defer и что они выведут.

func main() {
	n := 0

	defer fmt.Println(n) // 0, тут мы сразу передали в печать значение 0

	
	defer func(n int) {
		fmt.Println(n) // 0. Пусть вас не смущает, что печатается n. Этот n является аргументом анонимки, а не глобальный
		// Это эффект затенения, когда переменная затеняет собой одноименную, но уровнем видимости выше
	}(n) // 	Этот дефер обернут в анонимку, однако, n передается сразу на инициализации

	defer func() {
		fmt.Println(n) // 2, т.к. анонимка просчитает себя только в момент вызова 
	}()


	n++ // n = 1  			 <---- Начинай читать код тут
	defer func() {
		n++ // n = 2 <----- Первым будет выполнен этот defer, т.к. по LIFO он "наверху" стакана, а следом пойдут вышестоящие, тут без подвоха (?)
	}()  
}

Картина меняется сразу, если мы начнем передавать не значение n, а указатель.

func main() {
	zero := 0
	n := &zero

	// Отработает последним
	defer fmt.Println(*n) // 0, а тут не смотря на указатель, мы его разыменовали сразу и передали значение

	// Отработает третьим
	defer fmt.Println(n) //0xc000010120. Но если убрать разыменоание, во всех деферах будет один указатель

	// Отработает вторым
	defer func(n *int) {
		fmt.Println(*n) // 2
		fmt.Println(n)  // 0xc000010120

	}(n)

	// Отработает первым
	defer func() {
		fmt.Println(*n) // 2
		fmt.Println(n)  // 0xc000010120
	}()

	*n++ // n = 1  			 <---- Начинай читать код тут
	defer func() {
		*n++ // n = 2
	}()
}

И ответ на заголовок может показаться банальным, но анонимка или инлайн, все зависит от ваших целей. Хотите зафиксировать defer`ом состояние переменной в какой-то момент времени? Или хотите работать с "конечным" результатом? Тут речь не о идиоматике языка, а скорее о его возможностях.

Жизнь defer после return

Когда вы будете читать о defer, в материалах укажут, что он выполняется в конце работы функции. Как правило, на этом все и заканчивается. Более того, в работе вы можете и не заметить нюанса, а именно, defer отрабатывает ПОСЛЕ отработки return, но до непосредственного схлопывания стека.

Проверить это достаточно просто.

func Increment(n int) int {
	defer func() {
		n++ // Инкремент будет выполнен после копирования n в возврат
	}()
	return n // 1
}

func main() {
	fmt.Println(Increment(1)) // 1. Инкремента нет
}

Вы скажете, что произошло копирование, как в примере выше. Достаточно на return накинуть анонимку, что б выполнить инкремент и передать его результат. Проверяем

func Increment(n int) int {
	defer func() {
		n++
	}()
	return func() int {
		return n // 1
	}()
}

func main() {
	fmt.Println(Increment(1))
}

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

func Increment(n *int) *int {
	defer func() {
		*n++
	}()
	return n // Возвращаем именно указатель, а не его копию
}

func main() {
	n := 1
	fmt.Println(*Increment(&n)) //2. Разменуем
}

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

Когда это может выстрелить в работе и как бороться?

У вас в структуре есть мьютекс и он покрывает >1 критической секции? Метод открытый для внешнего вызова сам вызывает через return портянку мелких методов с мьютексом?

type Example struct {
	m sync.Mutex
}

func (e *Example) Global() error {
	e.m.Lock()
	defer e.m.Unlock()

	return e.proxy()
}

func (e *Example) proxy() error {
	return e.local()
}

func (e *Example) local() error {
	e.m.Lock() // А мьютекс выше еще закрыт, а мы уже тут, а еще мы в main :)
	defer e.m.Unlock()

	return nil
}

func main() {
	n := &Example{}
	fmt.Println(n.Global())
}

Как починить это? Ответ простой и анонимный.
Мы заключим работу мьютекса в анонимную функцию, что б defer отработал внутри нее и global пошла дальше, с открытым мьютекcом

type Example struct {
	m sync.Mutex
}

func (e *Example) Global() error {
	func() {
		e.m.Lock()
		defer e.m.Unlock()
	}()

	return e.proxy()
}

func (e *Example) proxy() error {
	return e.local()
}

func (e *Example) local() error {
	e.m.Lock() // А мьютекс выше еще закрыт, а мы уже тут, а еще мы в main :)
	defer e.m.Unlock()

	return nil
}

func main() {
	n := &Example{}
	fmt.Println(n.Global())
}

А что если обернуть это все дело в горутину, без использования анонимной функции?

type Example struct {
	m sync.Mutex
}

func (e *Example) Global() error {
	e.m.Lock()
	defer e.m.Unlock()

	return e.proxy()
}

func (e *Example) proxy() error {
	return e.local()
}

func (e *Example) local() error {
	e.m.Lock() // А мьютекс выше еще закрыт, а мы уже тут :)
	defer e.m.Unlock()

	return nil
}

func main() {
	n := &Example{}
	ch := make(chan struct{})
	go func() {
		defer func() {
			ch <- struct{}{}
		}()
		fmt.Println(n.Global())
	}()

	<-ch
}

Тут блокировка происходит, как вышестоящие, т.к. рантайм Go понимает, что выхода можно не ждать, все горутины заблокированы. Следуя этому правилу, мы можем доработать код и он не упадет. Достаточно выключить в него еще одну горутину, которая запишет в тот же канал хоть что-то

// Нужно добавить рядом с горутиной, вызывающей Global
go func() {
		defer func() {
			ch <- struct{}{}
		}()
		time.Sleep(time.Second * 10)
	}()

Это решение работает. Программа завершит работу без ошибок и паник через 10 секунд, однако, мы потеряли выполнение целого куска Global, который был вызван. Обойти это можно только прибегая к закрыванию defer`a в Global в анонимную функцию

type Example struct {
	m sync.Mutex
}

func (e *Example) Global() error {
	func() {
		e.m.Lock()
		defer e.m.Unlock()
	}()

	return e.proxy()
}

func (e *Example) proxy() error {
	return e.local()
}

func (e *Example) local() error {
	e.m.Lock() // А мьютекс выше еще закрыт, а мы уже тут :)
	defer e.m.Unlock()

	return nil
}

func main() {
	n := &Example{}
	ch := make(chan struct{})
	go func() {
		defer func() {
			ch <- struct{}{}
		}()
		fmt.Println(n.Global())
	}()

	go func() {
		defer func() {
			ch <- struct{}{}
		}()
		time.Sleep(time.Second * 10)
	}()

	<-ch
}

А может ли defer затормозить выполнение кода?

Да. В качестве примера предположим, что у нас есть канал в структуре. У структуры есть читатель и писатель канала. Задача писателя записать в канал структуру, как только произойдет сложная операция, причем, без разницы, с каким результатом

type Example struct {
	m  sync.Mutex
	ch chan struct{}
	t  time.Time
}

func (e *Example) A() {
	time.Sleep(time.Second) // Например, вы вставляете большой объем данных
	defer func() {          // Хотим, что б читатель приступил к работе, как только вставка закончится, либо произойдет какая-то иная беда
		e.ch <- struct{}{}
	}()

	// Имитация очень тяжелой задачи после вставки
	time.Sleep(time.Second * 10)
}

func (e *Example) B() {
	<-e.ch
	fmt.Printf("Script ended in: %.2f seconds\n", time.Since(e.t).Seconds())
}

func main() {
	n := &Example{
		ch: make(chan struct{}),
		t:  time.Now(),
	}

	wg := sync.WaitGroup{}
	wg.Add(2)
	go func() {
		defer func() {
			wg.Done()
		}()
		n.A()
	}()

	// Эта горутина никогда не завершит работу, т.к. верхняя запишет в канал раньше
	go func() {
		defer func() {
			wg.Done()
		}()
		n.B()
	}()

	wg.Wait()
}

Этот код отработает за ~11 секунд. Эту ситуацию и тут поможет обойти анонимка.

Вместо вывода

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

P.S.

Эта статья не претендует на какие-то открытия. Это, скорее, желание попробовать, какого это написать статью для Хабра со скромным желанием кому-то помочь. Прошу сильно не пинать :)
Рекламы ТГ и других соц сетей не будет, я тут за идею.


Не болейте <3