❓ Расскажите о механизме мьютексов в Go и укажите существующие типы

Mutex (mutual exclusion — взаимное исключение) — примитив синхронизации для защиты критической секции программы. Он предотвращает гонки данных и deadlock’и, обеспечивая эксклюзивный доступ к ресурсу.

Критическая секция — участок кода, где одновременно может работать только одна горутина.

➡️ sync.Mutex — эксклюзивная блокировка
Только одна горутина может захватить мьютекс и получить доступ к ресурсу.

var mu sync.Mutex

func increment() {
    mu.Lock()
    count++
    mu.Unlock()
}

Здесь мы рассматриваем защиту глобальной переменной count при инкременте из множества горутин.

➡️ sync.RWMutex — концептуально то же самое, что и Mutex, но дает вам немного больше контроля над памятью.
Позволяет:
RLock — множеству горутин читать одновременно.
Lock — только одному писателю, без читателей.

var mu sync.RWMutex

func set(key, value string) {
    mu.Lock()
    cache[key] = value
    mu.Unlock()
}

func get(key string) string {
    mu.RLock()
    defer mu.RUnlock()
    return cache[key]
}

Дает безопасный доступ к кэшу — много читателей, один писатель.

🐸 Библиотека Go для собеса

❓ Что собой представляет «затенение» переменной (shadowing) в Go

➖ В Go «затенение» (shadowing) происходит, когда переменная, объявленная в локальной области видимости, имеет такое же имя, как и переменная во внешней области видимости. Внутренняя переменная «затеняет» внешнюю, делая её недоступной.

package main

import (
    "fmt"
)

func main() {
    x := 10
    
    if true {
        x := 5 // затенение внешней переменной x
        fmt.Println(x) // выводит 5
    }

    fmt.Println(x) // выводит 10
}

➖ «Затенение» может быть особенно запутывающим, когда оно касается переменных, полученных из результатов функций, таких как err. Пример часто встречающегося кода в Go:

value, err := someFunction()
if err != nil {
    // обработка ошибки
}

// ...

value2, err := anotherFunction() // новое затенение переменной err
if err != nil {
    // обработка ошибки
}

Если использовать := вместо =, вы создадите новую переменную err, которая «затенит» переменную err из внешней области видимости. Это может привести к неправильной обработке ошибок, так как внешняя ошибка будет проигнорирована.

❕Обнаружение затенения:

1. go vet -shadow ./...
2. golangci-lint run --enable shadow
3. Использование инструмента shadow:

$ go get -u golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
$ go vet -vettool=$(which shadow)

🐸 Библиотека Go для собеса

❓ Как минимизировать использование памяти в Go при работе с большими структурами данных

➡️ Избегайте глобальных переменных, они остаются в памяти на весь срок работы программы.

➡️ Выбирайте правильные типы данных используйте int8, int16 вместо int, если диапазон позволяет.

➡️ Используйте sync.Pool для повторного использования часто создаваемых объектов.

➡️ Ленивая инициализация, инициализируйте данные только по мере необходимости.

➡️ Передавайте указатели на структуры, это экономит память по сравнению с копиями.

➡️ Срезы против массивов — используйте массивы, если размер данных известен заранее.

➡️ Освобождение ресурсов, присваивайте nil неиспользуемым структурам.

➡️ Используйте буферизацию, она снижает количество выделений памяти.

➡️ Оптимизируйте структуры, переупорядочив поля, можно снизить их размер.

🐸 Библиотека Go для собеса

❓ Что включает в себя набор примитивов синхронизации пакета sync в Go

Примитивы синхронизации — инструменты (в основном из пакета sync), которые обеспечивают безопасную работу с общими данными и координацию горутин.

• sync.Mutex — базовый механизм взаимного исключения. Позволяет заблокировать доступ к ресурсу, чтобы только одна горутина могла его изменять в текущий момент.

• sync.RWMutex — вариант мьютекса с разделением на блокировку для чтения и записи:
Одновременно могут выполняться несколько операций чтения.
Запись возможна только при полном исключении доступа.

• sync.WaitGroup — позволяет дождаться завершения группы горутин. Удобен для синхронного старта/остановки процессов.

• sync.Once — гарантирует однократное выполнение кода, даже при множественных вызовах из разных горутин.

• sync.Cond — условная переменная, при помощи которой горутина может "заснуть" до наступления определённого события.

Go предлагает два подхода к синхронизации — через примитивы sync и через каналы. Первые дают низкоуровневый контроль, вторые — более декларативный способ координации.

🐸 Библиотека Go для собеса