🤔 В чём отличие UInt от Int?

- Int — знаковое целое число, может быть как положительным, так и отрицательным.
- UInt — беззнаковое целое число, только 0 и положительные значения.
UInt полезен, если ты точно знаешь, что число не может быть отрицательным (например, размер массива). Однако арифметические операции между Int и UInt требуют явного преобразования.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие преимущества есть у Go?

Go (или Golang) обладает рядом преимуществ, которые делают его популярным.

🟠Простота и лаконичность
Был разработан с упором на простоту синтаксиса и лаконичность. Это делает язык легким для изучения и чтения кода. Минимализм языка позволяет разработчикам сосредоточиться на решении задач, а не на сложностях синтаксиса.

🟠Высокая производительность
Компилируется в машинный код, что обеспечивает высокую производительность выполнения программ. Производительность Go сопоставима с производительностью программ, написанных на C или C++, благодаря низкоуровневой оптимизации компилятора.

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

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

🟠Сильная система типов и безопасность памяти
Имеет строгую систему типов, которая помогает предотвращать ошибки на этапе компиляции. В языке отсутствуют неявные преобразования типов, что снижает вероятность ошибок. Также Go управляет памятью с помощью встроенного сборщика мусора (garbage collector), что предотвращает утечки памяти.

🟠Встроенная поддержка
Стандартных инструментов
Поставляется с богатым набором встроенных инструментов для разработки, таких как:
go fmt для автоматического форматирования кода.
go test для запуска тестов.
go build и go run для сборки и выполнения программ.
go doc для генерации документации.

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

🟠Стандартная библиотека
Обширна и покрывает многие аспекты разработки, такие как работа с сетью, работа с файлами, веб-разработка и многое другое. Это позволяет разработчикам быстро начинать работу, не тратя время на поиск и интеграцию сторонних библиотек.

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

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие бывают примитивы синхронизации?

Примитивы — это средства, предотвращающие конфликты между потоками:
- Mutex — взаимное исключение.
- Semaphore — ограничение количества одновременных доступов.
- Spinlock — цикл ожидания без сна.
- RWLock (чтение-запись) — позволяет множественное чтение, но только одну запись.
- Atomic операции — безопасные базовые действия без блокировок.
- Condition variables — ожидание события от другого потока.
- Channel / Queue — для безопасного обмена данными (особенно в Go).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое SLI?

Это конкретная метрика, используемая для измерения качества обслуживания сервиса. SLI показывает, насколько хорошо сервис соответствует определенным критериям, установленным в SLO (Service Level Objective).

🚩Основные компоненты

🟠Доступность (Availability)
Процент времени, в течение которого сервис доступен для пользователей. Пример: "99.9% времени в течение месяца."
🟠Производительность (Performance)
Метрики, такие как время отклика или пропускная способность. Пример: "Среднее время отклика 200 миллисекунд."
🟠Время восстановления (MTTR - Mean Time to Recovery)
Среднее время, необходимое для восстановления сервиса после сбоя. Пример: "Среднее время восстановления 1 час."
🟠Время на устранение инцидентов (MTTA - Mean Time to Acknowledge)
Среднее время на принятие мер после обнаружения проблемы. Пример: "Среднее время реакции на инцидент 30 минут."
🟠Процент ошибок (Error Rate)
Процент запросов, завершающихся ошибкой. Пример: "Процент ошибочных запросов не более 0.1%."

🚩Примеры

🟠Доступность
"Сервис был доступен 99.95% времени за последний месяц."
🟠Производительность
"Среднее время отклика сервиса за последний месяц составило 150 миллисекунд."
🟠Время восстановления (MTTR)
"Среднее время восстановления сервиса после сбоев за последний месяц составило 45 минут."
🟠Процент ошибок (Error Rate)
"Процент ошибочных запросов за последний месяц составил 0.05%."

🚩Различие между SLA, SLO и SLI

🟠SLA (Service Level Agreement)
Соглашение между поставщиком услуги и клиентом, включающее SLO и описывающее уровень обслуживания, который должен быть достигнут. SLA может включать последствия за невыполнение SLO.

🟠SLO (Service Level Objective)
Конкретные цели или метрики, которые определяют уровень обслуживания, которого должен достигнуть сервис. SLO являются частью SLA.

🟠SLI (Service Level Indicator)
Конкретные метрики, используемые для измерения фактической производительности сервиса относительно установленных SLO. SLI — это количественные показатели, которые служат основой для SLO.

🚩Важность

🟠Измерение качества услуг
SLI позволяют количественно измерять различные аспекты работы сервиса, такие как доступность и производительность.
🟠Контроль и мониторинг
SLI используются для постоянного мониторинга сервиса и обеспечения соответствия установленным SLO.
🟠Управление производительностью
SLI помогают выявлять проблемы в работе сервиса и принимать меры для их устранения.
🟠Улучшение сервиса
Анализ SLI позволяет улучшать качество обслуживания путем выявления и устранения узких мест и проблем.

🚩Пример использования

🟠Доступность
SLI: "99.9% времени сервис доступен."
SLO: "Сервис должен быть доступен не менее 99.9% времени в течение месяца."
SLA: "Если доступность падает ниже 99.9%, клиент получает компенсацию."
🟠Производительность
SLI: "Среднее время отклика 200 миллисекунд."
SLO: "Среднее время отклика не должно превышать 250 миллисекунд для 95% запросов."
SLA: "Если время отклика превышает 250 миллисекунд, клиент получает компенсацию."

Ставь 👍 и забирай 📚 Базу знаний

🤔 Где аллоцируется память для горутин?

Каждая горутина получает отдельный стек, который при старте весит около 2 килобайт. Он динамически увеличивается по мере необходимости (до мегабайт), а при простое — может быть сокращён.
Таким образом, память для горутины не аллоцируется в куче сразу, а используется адаптивно.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как каналы устроены в Go?

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

🚩Основы

Могут быть типизированы, что означает, что канал может передавать значения только одного определённого типа. Они могут быть объявлены и инициализированы с помощью ключевого слова chan:

ch := make(chan int) // Канал для передачи значений типа int

🚩Отправка и получение данных

Для отправки значения в канал используется оператор <-:

ch <- 10 // Отправка значения 10 в канал

Для получения значения из канала тот же оператор используется, но в другом контексте:

value := <-ch // Прочитать значение из канала и присвоить его переменной value

🚩Блокировки

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

🚩Буферизация

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

ch := make(chan int, 5) // Буферизированный канал с размером буфера 5

В буферизированном канале отправка не блокируется до тех пор, пока буфер не заполнится, и получение не блокируется до тех пор, пока буфер не опустеет.

🚩Закрытие каналов

Каналы можно закрывать, если больше нет необходимости отправлять через них данные. После закрытия канала нельзя отправлять данные, но можно продолжать получать данные до тех пор, пока канал не опустеет:

close(ch)

Проверка на то, что канал закрыт и данные исчерпаны, возможна в операции чтения:

value, ok := <-ch
if !ok {
    // Канал закрыт и все данные получены
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какая средняя сложность поиска по слайсу и по Map?

1. Слайс: поиск по индексу имеет сложность O(1), а поиск по значению — O(n), так как требуется линейный перебор элементов.
2. Map: средняя сложность поиска по ключу — O(1) благодаря хешированию, но в худшем случае (при коллизиях) может достигать O(n).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Чем stream отличается от unary?

В контексте gRPC (Google Remote Procedure Call) unary и stream — это два разных типа взаимодействия между клиентом и сервером.

🚩Unary RPC (Обычный вызов)

🟠Unary (унарный) вызов
это стандартный запрос-ответ:
Клиент отправляет одно сообщение → сервер отвечает одним сообщением.

service UserService {
    rpc GetUserInfo(UserRequest) returns (UserResponse);
}

Go-реализация Unary RPC

func (s *server) GetUserInfo(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    user := &pb.UserResponse{
        Id:    req.Id,
        Name:  "John Doe",
        Email: "john@example.com",
    }
    return user, nil // Обычный ответ
}

🚩Streaming RPC (Потоковый вызов)

В streaming RPC передача данных идёт потоком. gRPC поддерживает три вида стримов:

🟠Server Streaming (Поток от сервера)
Клиент отправляет один запрос → сервер возвращает поток ответов.

service UserService {
    rpc GetUserActivity(UserRequest) returns (stream ActivityResponse);
}

Go-реализация Server Streaming

func (s *server) GetUserActivity(req *pb.UserRequest, stream pb.UserService_GetUserActivityServer) error {
    activities := []string{"Login", "Upload File", "Logout"}
    for _, activity := range activities {
        err := stream.Send(&pb.ActivityResponse{Message: activity})
        if err != nil {
            return err
        }
        time.Sleep(time.Second) // Имитация задержки
    }
    return nil
}

🟠Client Streaming (Поток от клиента)
Клиент отправляет поток данных → сервер отвечает одним ответом.

service UploadService {
    rpc UploadFile(stream FileChunk) returns (UploadResponse);
}

Go-реализация Client Streaming

func (s *server) UploadFile(stream pb.UploadService_UploadFileServer) error {
    var totalSize int64
    for {
        chunk, err := stream.Recv()
        if err == io.EOF {
            return stream.SendAndClose(&pb.UploadResponse{Size: totalSize})
        }
        if err != nil {
            return err
        }
        totalSize += chunk.Size
    }
}

🟠Bidirectional Streaming (Двунаправленный поток)
Клиент и сервер обмениваются данными в потоке одновременно.

service ChatService {
    rpc Chat(stream ChatMessage) returns (stream ChatMessage);
}

Go-реализация Bi-directional Streaming

func (s *server) Chat(stream pb.ChatService_ChatServer) error {
    for {
        msg, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        response := &pb.ChatMessage{Text: "Echo: " + msg.Text}
        if err := stream.Send(response); err != nil {
            return err
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как определить количество символов для строки?

Для определения количества символов в строке в Swift используется свойство .count:
Внимание: .count возвращает количество графемных кластеров, а не байтов или Unicode-кодов. Например, emoji или диакритические символы могут быть представлены несколькими кодовыми точками, но отображаются как один символ.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие функции у map?

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

🚩Основные операции

🟠Объявление карты
Для этого используется ключевое слово map, после которого указываются типы ключей и значений.

var myMap map[string]int

🟠Инициализация карты
Это можно сделать с помощью функции make или литерала карты.

// Инициализация с помощью make
myMap = make(map[string]int)

// Инициализация с помощью литерала карты
myMap = map[string]int{
    "Alice": 25,
    "Bob":   30,
}

🟠Добавление и обновление элементов
Для этого используется синтаксис индексирования.

myMap["Charlie"] = 35
myMap["Alice"] = 26 // обновление значения по ключу "Alice"

🟠Извлечение значения по ключу
Для этого используется синтаксис индексирования.

age := myMap["Alice"]
fmt.Println(age) // 26

🟠Проверка существования ключа
Чтобы проверить это можно использовать двойное присваивание.

age, exists := myMap["David"]
if exists {
    fmt.Println("Age of David:", age)
} else {
    fmt.Println("David not found")
}

🟠Удаление элемента
Для этого используется встроенная функция delete.

delete(myMap, "Bob")

🟠Итерация по карте
Для этого используется цикл for range.

for key, value := range myMap {
    fmt.Printf("Key: %s, Value: %d\n", key, value)
}

Пример

package main

import (
    "fmt"
)

func main() {
    // Инициализация карты с помощью литерала
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // Добавление нового элемента
    myMap["Charlie"] = 35

    // Обновление существующего элемента
    myMap["Alice"] = 26

    // Извлечение значения по ключу
    age := myMap["Alice"]
    fmt.Println("Age of Alice:", age) // 26

    // Проверка существования ключа
    age, exists := myMap["David"]
    if exists {
        fmt.Println("Age of David:", age)
    } else {
        fmt.Println("David not found")
    }

    // Удаление элемента
    delete(myMap, "Bob")

    // Итерация по карте
    for key, value := range myMap {
        fmt.Printf("Key: %s, Value: %d\n", key, value)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое горутины?

Горутины — это легковесные потоки выполнения, которые выполняются параллельно в рамках одного процесса в Go. Они создаются с помощью ключевого слова `go` и могут быть выполнены одновременно, не требуя создания полноценного системного потока. Горутины потребляют меньше ресурсов, чем традиционные потоки, и могут работать асинхронно. Планировщик Go автоматически управляет их выполнением и распределяет между ядрами процессора.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему пустой интерфейс можно привести к любому типу?

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

🚩Пустой интерфейс

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

type interface{} interface {}

🚩Внутреннее представление интерфейсов в Go

🟠Type
Типа конкретного значения
🟠Value
Самого значения

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

🚩Приведение пустого интерфейса к конкретному типу

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

Присваивание значений пустому интерфейсу

package main

import "fmt"

func main() {
    var i interface{}
    i = 42
    fmt.Println(i) // 42

    i = "hello"
    fmt.Println(i) // hello
}

Утверждение типа (Type Assertion)

package main

import "fmt"

func main() {
    var i interface{} = "hello"

    // Утверждение типа с проверкой
    s, ok := i.(string)
    if ok {
        fmt.Println("String:", s)
    } else {
        fmt.Println("Not a string")
    }

    // Утверждение типа без проверки
    // Это вызовет панику, если тип не соответствует
    s = i.(string)
    fmt.Println("String:", s)
}

Использование switch для проверки типа

package main

import "fmt"

func printType(i interface{}) {
    switch v := i.(type) {
    case string:
        fmt.Println("String:", v)
    case int:
        fmt.Println("Integer:", v)
    case bool:
        fmt.Println("Boolean:", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    printType("hello")
    printType(42)
    printType(true)
    printType(3.14)
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Когда и зачем может пригодиться денормализация данных?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как работать со слайсами?

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

🚩Что это такое?

Это динамическая последовательность элементов одного типа, которая предоставляет доступ к части или всем элементам массива без копирования данных. Он содержит три компонента:
Указатель на массив.
Длина (количество элементов в слайсе).
Ёмкость (максимальное количество элементов, которые могут быть включены в слайс без перераспределения памяти).

🚩Почему они нужны?

Слайсы позволяют работать с массивами более гибко:
🟠Динамическая длина
В отличие от массивов, длина слайса может изменяться.
🟠Передача данных
Слайсы можно передавать в функции и возвращать из них, не копируя данные.
🟠Удобство работы
Предоставляют множество встроенных функций для работы с последовательностями данных.

🚩Создать слайс можно несколькими способами:

Из массива

    arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // слайс содержит элементы {2, 3, 4}
    

Используя make

slice := make([]int, 5)  // создаёт слайс длиной и ёмкостью 5, заполненный нулями    

Литерал слайса

slice := []int{1, 2, 3, 4, 5}    

🚩Основные операции

Доступ к элементам

fmt.Println(slice[0])  // выводит первый элемент слайса    

Изменение элементов

slice[1] = 10  // изменяет второй элемент слайса    

Добавление элементов

slice = append(slice, 6, 7)  // добавляет элементы 6 и 7 к слайсу    

Срезка (slicing)

newSlice := slice[1:3]  // создаёт новый слайс с элементами с 1-го по 3-й    

Рассмотрим пример функции, которая добавляет элемент в слайс и возвращает новый слайс

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3}
    nums = append(nums, 4)  // добавление элемента
    fmt.Println(nums)  // выводит [1, 2, 3, 4]
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что будет, если попытаться писать в закрытом канале?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое хэш-таблица?

Это структура данных, которая используется для хранения и поиска пар "ключ-значение". Обеспечивают быстрый доступ к данным по ключу, обычно с константным временем доступа в среднем случае. Основой работы хэш-таблицы является хеш-функция, которая преобразует ключ в индекс, по которому хранится значение.

🚩Основные компоненты

🟠Хеш-функция
Функция, которая принимает ключ и преобразует его в индекс массива, называемого "хэш-таблицей". Хорошая хеш-функция распределяет ключи равномерно по хэш-таблице, минимизируя количество коллизий.

🟠Хэш-таблица
Массив фиксированного размера, где каждый элемент называется "корзиной" (bucket). Корзина может содержать одно или несколько значений.

🟠Коллизии
Ситуация, когда два разных ключа хешируются в один и тот же индекс. Коллизии решаются с помощью различных методов, таких как цепочки (chaining) или открытая адресация (open addressing).

🚩Принцип работы

🟠Вставка
Хеш-функция вычисляет индекс для данного ключа. Значение помещается в соответствующую корзину по этому индексу. Если возникает коллизия, используется метод разрешения коллизий.

🟠Поиск
Хеш-функция вычисляет индекс для ключа. Корзина по этому индексу проверяется на наличие значения. Если значение найдено, оно возвращается; если нет, возвращается индикатор отсутствия значения.

🟠Удаление
Хеш-функция вычисляет индекс для ключа. Значение удаляется из соответствующей корзины. При необходимости корректируются ссылки или структура данных для разрешения коллизий.

🚩Плюсы и минусы

➕Быстрый доступ
Среднее время доступа к элементу составляет O(1).
➕Простота использования
Обеспечивает простой интерфейс для вставки, поиска и удаления данных.
➖Коллизии
Требуют дополнительных механизмов для разрешения, что может усложнить реализацию.
➖Зависимость от хеш-функции
Эффективность хэш-таблицы зависит от качества хеш-функции.
➖Перераспределение
При увеличении количества элементов может потребоваться перераспределение и увеличение размера таблицы, что временно снижает производительность.

package main

import "fmt"

func main() {
    // Создание карты
    myMap := make(map[string]int)

    // Вставка значений
    myMap["Alice"] = 25
    myMap["Bob"] = 30

    // Поиск значений
    value, exists := myMap["Alice"]
    if exists {
        fmt.Println("Alice:", value) // Alice: 25
    } else {
        fmt.Println("Alice not found")
    }

    // Удаление значений
    delete(myMap, "Alice")
    _, exists = myMap["Alice"]
    if !exists {
        fmt.Println("Alice has been deleted") // Alice has been deleted
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Зачем нужен пустой интерфейс?

Пустой интерфейс нужен для универсальности: он позволяет писать код, не привязанный к конкретным типам. Примеры использования включают универсальные контейнеры (например, массивы и словари) и функции, работающие с любыми типами. Например, в логировании часто используют interface{} для передачи любых данных.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Зачем синхронизировать доступ данных?

В многопоточных (параллельных) программах горутины (goroutines) могут одновременно изменять одни и те же данные. Если не синхронизировать доступ, это приведёт к гонке данных (data race), когда несколько потоков читают/пишут одно и то же значение одновременно.

🚩`sync.Mutex` (мьютексы — блокировка данных)

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

package main

import (
  "fmt"
  "sync"
)

var (
  counter int
  mutex   sync.Mutex
)

func increment(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.Lock()   // Блокируем доступ
  counter++      // Изменяем данные
  mutex.Unlock() // Разблокируем доступ
}

func main() {
  var wg sync.WaitGroup

  for i := 0; i < 1000; i++ {
    wg.Add(1)
    go increment(&wg)
  }

  wg.Wait()
  fmt.Println("Итоговый счетчик:", counter) // 1000
}

🚩`sync.RWMutex` (разделяемая блокировка)

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

var (
  data  int
  mutex sync.RWMutex
)

func readData(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.RLock() // Разрешаем чтение
  fmt.Println("Читаем данные:", data)
  mutex.RUnlock()
}

func writeData(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.Lock() // Блокируем на запись
  data++
  mutex.Unlock()
}

🚩`sync.WaitGroup` (ожидание горутин)

Позволяет дождаться завершения всех горутин без блокировки данных.

var wg sync.WaitGroup

wg.Add(2)   // Ожидаем 2 горутины
go func() {
  defer wg.Done()
  fmt.Println("Горутина 1 завершилась")
}()
go func() {
  defer wg.Done()
  fmt.Println("Горутина 2 завершилась")
}()

wg.Wait()  // Ждём завершения всех горутин
fmt.Println("Все горутины завершены")

🚩`sync/atomic` (атомарные операции)

Атомарные операции быстрее мьютексов и гарантируют безопасное обновление переменных без гонок данных.

import "sync/atomic"

var counter int64

func incrementAtomic() {
  atomic.AddInt64(&counter, 1) // Атомарное увеличение
}

🚩Каналы (лучший способ в Go)

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

package main

import "fmt"

func main() {
  ch := make(chan int) // Канал для передачи данных

  go func() {
    ch <- 42 // Отправляем данные
  }()

  data := <-ch // Получаем данные
  fmt.Println("Получено:", data)
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как проводить тестирование в Go?

Тестирование в Go реализуется с помощью встроенного пакета testing. Тесты пишутся как функции с именами, начинающимися на Test, принимающими параметр *testing.T. Для запуска тестов используется команда go test. Также доступны инструменты для бенчмарков (Benchmark), покрытия кода тестами (-cover) и работы с примерами (Example).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие есть особенности синтаксиса получения и записи значений в map?

Карты (maps) представляют собой ассоциативные массивы, которые связывают ключи с соответствующими значениями. Работа с картами включает получение и запись значений, и Go предоставляет удобный синтаксис для этих операций. Рассмотрим особенности синтаксиса получения и записи значений в карты.

🚩Получение значений

🟠Простое получение значения по ключу
Для этого используется синтаксис индексирования

value := myMap[key]

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    value := myMap["Alice"]
    fmt.Println("Alice:", value) // Alice: 25
}

🟠Проверка существования ключа
Для этого используется синтаксис двойного присваивания

value, exists := myMap[key]

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    value, exists := myMap["Charlie"]
    if exists {
        fmt.Println("Charlie:", value)
    } else {
        fmt.Println("Charlie not found")
    }
}

🚩Запись значений

🟠Добавление или обновление значения
Для этого используется синтаксис индексирования:

myMap[key] = value

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{}

    // Добавление значений
    myMap["Alice"] = 25
    myMap["Bob"] = 30

    fmt.Println("Map:", myMap) // Map: map[Alice:25 Bob:30]

    // Обновление значения
    myMap["Alice"] = 26
    fmt.Println("Updated Map:", myMap) // Updated Map: map[Alice:26 Bob:30]
}

🟠Удаление значений из карты
Для этого используется встроенная функция delete:

delete(myMap, key)

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // Удаление значения по ключу
    delete(myMap, "Alice")
    fmt.Println("Map after deletion:", myMap) // Map after deletion: map[Bob:30]
}

🟠Подводные камни и особенности

🟠Отсутствие ключа
Если ключ отсутствует в карте, при попытке получения значения будет возвращено нулевое значение типа значения карты. Например, для карты map[string]int это будет 0.

        package main

    import "fmt"

    func main() {
        myMap := map[string]int{
            "Alice": 25,
        }

        value := myMap["Bob"] // Ключ "Bob" отсутствует
        fmt.Println("Value:", value) // Value: 0
    }
    

🟠Запись в неинициализированную карту
Нельзя записывать значения в nil карту. Это приведет к панике времени выполнения.

        package main

    func main() {
        var myMap map[string]int // nil карта
        myMap["Alice"] = 25      // Вызовет панику: runtime error: assignment to entry in nil map
    }
    

🟠Итерация по карте
Порядок итерации по карте не определен и может различаться между разными запусками программы.

        package main

    import "fmt"

    func main() {
        myMap := map[string]int{
            "Alice": 25,
            "Bob":   30,
            "Carol": 35,
        }

        for key, value := range myMap {
            fmt.Printf("%s: %d\n", key, value)
        }
    }

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое воркстилинг (work stealing)?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний