🤔 Какие есть возможности у создания дочернего контекста данных?

1. Отмена операций:
- С помощью WithCancel можно отменить дочерние контексты при необходимости.
2. Управление временем выполнения:
- Установить тайм-аут или дедлайн для операций с WithTimeout или WithDeadline.
3. Передача данных:
- С WithValue можно передать данные (например, идентификаторы пользователя) между горутинами.
4. Изоляция задач:
- Дочерние контексты изолируют задачи, сохраняя независимость от других операций.

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

🤔 Как завершить много горутин?

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

🚩Использование каналов для управления горутинами

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

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(stopCh <-chan struct{}, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-stopCh:
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    stopCh := make(chan struct{})

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(stopCh, &wg, i)
    }

    // остановка горутин после 3 секунд
    time.Sleep(3 * time.Second)
    close(stopCh) // отправка сигнала всем горутинам остановиться
    wg.Wait()    // ожидание завершения всех горутин
}

🟠Использование пакета context

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

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func worker(ctx context.Context, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(ctx, &wg, i)
    }

    wg.Wait() // ожидание завершения всех горутин
    cancel()  // убедиться, что все ресурсы освобождены
}

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

🤔 Как завершить много горутин

Для завершения множества горутин обычно используется канал (например, done), через который можно отправить сигнал для завершения работы. Также можно использовать контексты (context.Context) для отмены, чтобы горутины могли проверять его состояние и корректно завершаться при получении сигнала отмены. Такой подход обеспечивает упорядоченное и безопасное завершение множества горутин.

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

🤔 Можно ли использовать один и тот же буфер []byte в нескольких горутинах?

Может быть как безопасным, так и небезопасным, в зависимости от контекста и конкретного использования.

🚩Когда использование небезопасно

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            buffer[i] = byte(i) // Несколько горутин одновременно модифицируют буфер
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

🚩Безопасное использование одного буфера

🟠Только чтение
Если несколько горутин только читают из буфера, это безопасно. Пример безопасного использования:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < len(buffer); i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Printf("buffer[%d]: %c\n", i, buffer[i])
        }(i)
    }

    wg.Wait()
}

🟠Использование мьютексов
Для синхронизации доступа к буферу используйте мьютексы (sync.Mutex). Это гарантирует, что только одна горутина в данный момент модифицирует буфер.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            mu.Lock()
            buffer[i] = byte(i)
            mu.Unlock()
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

🟠Копирование буфера
Если каждая горутина должна работать с независимой копией буфера, создавайте копии для каждой горутины.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            localBuffer := make([]byte, len(buffer))
            copy(localBuffer, buffer)
            localBuffer[i] = byte(i)
            fmt.Printf("Goroutine %d: %s\n", i, localBuffer)
        }(i)
    }

    wg.Wait()
}

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

🤔 Как работает поиск по дереву?

В дереве (например, бинарном дереве поиска):
- Сравнивается ключ с корнем.
- Если меньше — идём влево, если больше — вправо.
- Так повторяется, пока не найдётся элемент или не достигнется конец.
В сбалансированных деревьях (B-tree, AVL) время поиска — логарифмическое, что намного быстрее, чем линейный перебор, особенно при больших объёмах данных.

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

🤔 Что такое EXPLAIN?

EXPLAIN — это команда в SQL, которая показывает, как база данных выполняет SQL-запрос. Она помогает оптимизировать запросы, анализируя их план выполнения.

🚩Как работает?

Когда вы пишете EXPLAIN перед SQL-запросом, база данных не выполняет его, а показывает пошаговый процесс выполнения. Это помогает понять:
Какие индексы используются
Какие таблицы сканируются
Какие соединения (JOIN) выполняются
Оценить производительность запроса

EXPLAIN SELECT * FROM users WHERE age > 30;

Выход (пример)

Seq Scan on users  (cost=0.00..25.00 rows=10 width=100)

🚩`EXPLAIN ANALYZE` — глубокий анализ

Добавляет реальное время выполнения запроса

EXPLAIN ANALYZE SELECT * FROM users WHERE age > 30;

🚩Оптимизация запросов с `EXPLAIN`

Использование индексов

CREATE INDEX idx_users_age ON users(age);

Правильный порядок JOIN

EXPLAIN SELECT * FROM orders JOIN users ON orders.user_id = users.id;

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

🤔 Что такое mutex, какие они бывают и как их использовать?

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

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

🤔 Что такое len и capacity в slice Go?

Слайсы имеют две основные характеристики: длину (len) и емкость (capacity). Понимание этих характеристик важно для эффективного использования слайсов.

🚩Длина (len)

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

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    fmt.Println("Length:", len(slice)) // Length: 5
}

🚩Емкость (capacity)

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

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5)
    fmt.Println("Length:", len(slice))   // Length: 3
    fmt.Println("Capacity:", cap(slice)) // Capacity: 5
}

🚩Взаимосвязь длины и емкости

🟠Длина (`len`)
Определяет текущее количество элементов в слайсе.
Используется для операций чтения и записи.

🟠Емкость (`cap`)
Определяет максимальное количество элементов, которые могут быть добавлены в слайс без выделения новой памяти.
Емкость может увеличиваться автоматически при добавлении элементов через функцию append.

🚩Использование append

Когда вы добавляете элементы в слайс с помощью append, если текущей емкости недостаточно, автоматически выделяет новый массив с большей емкостью, копирует существующие элементы в новый массив и добавляет новые элементы.

package main

import "fmt"

func main() {
    slice := make([]int, 2, 2)
    slice[0] = 1
    slice[1] = 2

    fmt.Println("Before append:", slice, "Len:", len(slice), "Cap:", cap(slice)) // [1 2] Len: 2 Cap: 2

    // Добавляем элемент, превышающий текущую емкость
    slice = append(slice, 3)

    fmt.Println("After append:", slice, "Len:", len(slice), "Cap:", cap(slice)) // [1 2 3] Len: 3 Cap: 4
}

🚩Полная форма нарезки (full slice expression)

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

package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    newSlice := original[1:3:4]
    fmt.Println("New Slice:", newSlice)       // [2 3]
    fmt.Println("Length:", len(newSlice))     // 2
    fmt.Println("Capacity:", cap(newSlice))   // 3
}

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

🤔 Сколько весит слайс в байтах?

Слайс в Go — это структура-обёртка, которая весит 24 байта:
- 8 байт — указатель на массив.
- 8 байт — длина.
- 8 байт — вместимость (capacity).
Это не считая данных, на которые указывает слайс — они хранятся отдельно.

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

🤔 В чем разница между буферизированными и небуферизированными каналами?

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

🚩Небуферизированные каналы

Не имеют внутренней емкости, т.е. они не могут хранить значения. Эти каналы требуют, чтобы отправитель и получатель были готовы обмениваться данными одновременно. Если одна сторона не готова, другая будет заблокирована:
Отправка данных в него блокирует отправителя до тех пор, пока получатель не прочитает данные из канала.
Получение данных из него блокирует получателя до тех пор, пока другая горутина не отправит данные в канал.

ch := make(chan int) // Создание небуферизированного канала
go func() {
    val := <-ch // Блокируется, ожидая данные
    fmt.Println("Received:", val)
}()
ch <- 3 // Блокируется, пока данные не будут получены

🚩Буферизированные каналы

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

ch := make(chan int, 2) // Создание буферизированного канала с емкостью 2
ch <- 1 // Отправка данных без блокировки
ch <- 2 // Отправка данных без блокировки
go func() {
    val := <-ch // Получение данных без блокировки
    fmt.Println("Received:", val)
}()

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

🤔 В чем разница TCP и UDP?

TCP (Transmission Control Protocol) — это протокол, который обеспечивает надёжную передачу данных, гарантируя, что все пакеты будут доставлены в правильном порядке и без потерь. TCP устанавливает соединение между клиентом и сервером перед передачей данных, проверяет целостность пакетов и управляет повторной передачей потерянных данных. UDP (User Datagram Protocol) не гарантирует доставку пакетов, не обеспечивает контроль за порядком их получения и не требует установления соединения, что делает его более быстрым, но менее надёжным. UDP предпочтителен для приложений, где скорость важнее надёжности, например, для видеостриминга или онлайн-игр.

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

🤔 Что такое составной индекс?

Составной индекс (Composite Index) — это индекс, который создаётся сразу на нескольких колонках таблицы базы данных. Он помогает ускорить поиск и сортировку данных, особенно если запросы используют условия по нескольким полям.

🚩Зачем нужен составной индекс?

🟠Оптимизация запросов
Если часто выполняются запросы с фильтрацией по нескольким колонкам (WHERE col1 = X AND col2 = Y), составной индекс ускоряет их выполнение.
🟠Ускорение сортировки
Если запросы используют ORDER BY col1, col2, индекс помогает избежать дополнительной сортировки.
🟠Снижение нагрузки на сервер
Без индекса СУБД вынуждена выполнять полный перебор (Full Table Scan), что занимает больше времени.

🚩Как работает составной индекс?

Он строится по нескольким колонкам и фактически представляет собой отсортированную структуру данных. Например, в PostgreSQL или MySQL создаётся так:

CREATE INDEX idx_name ON users (last_name, first_name);

Теперь база данных будет использовать индекс для запросов:

SELECT * FROM users WHERE last_name = 'Иванов' AND first_name = 'Петр';

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

🤔 Какие известны алгоритмы балансировки нагрузки?

Наиболее популярные:
- Round Robin — по очереди между серверами.
- Least Connections — наименьшее число активных соединений.
- IP Hashing — клиент всегда попадает на один и тот же сервер.
- Random — случайный выбор.
- Consistent Hashing — устойчив к изменениям числа серверов, часто используется в распределённых кешах.
- Load-based (метрический) — выбор по метрикам (CPU, RAM, отклик), требует мониторинга.

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

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

1. Получение значения: value, exists := map[key], где exists указывает, присутствует ли ключ.
2. Запись значения: map[key] = value.
3. Удаление ключа: delete(map, key).

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

🤔 Что такое репликация?

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

🚩Цели

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

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

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

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

🚩Типы

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

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

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

🤔 Можно ли изменить определенный символ в строке?

Нет, строки в Go — неизменяемые.
Чтобы «изменить» символ в строке:
1. Преобразуй строку в срез rune (если нужна работа с Unicode-символами).
2. Измени нужный элемент.
3. Преобразуй обратно в string.
Это создаёт новую строку в памяти. Изменение «на месте» невозможно.

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

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

Контексты (context.Context) представляют собой интерфейс, который используется для передачи мета-данных, управления сроками действия и отменой операций в иерархии вызовов функций. Основная цель контекста — обеспечение способа для остановки выполнения программы (например, запросов или подпроцессов) по требованию. Это особенно полезно в сетевых приложениях, где вам может потребоваться прервать выполнение операции, которая больше не требуется или занимает слишком много времени.

🚩Ключевые особенности

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

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

🟠Сроки выполнения
Контекст может иметь установленный таймаут или дедлайн, после достижения которого он автоматически отменяется.

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

🚩Создание и использование контекста

🟠context.Background()
Возвращает пустой контекст, который никогда не отменяется. Обычно используется в основной функции и при инициализации.

🟠context.TODO()
Используется для указания, что должен быть предоставлен подходящий контекст. Обычно применяется в разработке и при рефакторинге.

🟠context.WithCancel(parent Context) (ctx Context, cancel CancelFunc)
Создает новый контекст с возможностью отмены.

🟠context.WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
Создает контекст, который автоматически отменяется в указанный deadline.

🟠context.WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
Аналогичен WithDeadline, но устанавливает время жизни контекста на основе заданного таймаута.

func operation1(ctx context.Context) {
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("operation1 completed")
    case <-ctx.Done():
        fmt.Println("operation1 cancelled")
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    go operation1(ctx)

    // Дожидаемся завершения или отмены операции
    <-ctx.Done()
    if err := ctx.Err(); err != nil {
        fmt.Println("main:", err)
    }
}

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

🤔 Какие виды индексов в PostgreSQL?

PostgreSQL поддерживает:
- B-Tree — по умолчанию, для равенства и диапазонов.
- Hash — для быстрого поиска по точному совпадению.
- GIN (Generalized Inverted Index) — для массивов, JSONB, полнотекстового поиска.
- GiST (Generalized Search Tree) — для гео-данных и поиска по диапазону.
- BRIN (Block Range Index) — для очень больших таблиц с логически отсортированными данными.
- Expression indexes — индексы по вычислениям, а не просто по полю.
- Partial indexes — индексы по части строк (например, только по активным записям).

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

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

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

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

Горутины (goroutines) — лёгкие потоки, управляемые Go.
Планировщик (scheduler) — распределяет горутины по потокам ОС.
Модель памяти — управление стеком и кучей.
Сборщик мусора (GC) — автоматически очищает неиспользуемую память.
Syscalls — взаимодействие с ОС.

🚩Горутины и планировщик (scheduler)

Горутины легче, чем потоки ОС: Go может запускать миллионы горутин, а планировщик (M:N) распределяет их по потокам ОС.
Go использует M:N-модель, где:
- M — системные потоки (OS threads).
- N — горутины (goroutines).
- P — процессоры (logical processors) — управляют выполнением горутин.
P привязан к M, а G (горутины) распределяются между `P` динамически.
Это позволяет Go эффективно использовать CPU без ручного управления потоками.

Goroutine (G1, G2, G3, ...) 
    ↓  
Scheduler → P (Processor) → M (OS Thread) → CPU

🚩Управление памятью и стеком

Стек (stack) в Go динамический — он начинается с 2 KB и увеличивается при необходимости.
Если стек заполнен, Go автоматически расширяет его.
В отличие от C, Go не требует malloc/free, так как есть GC (garbage collector).

🚩Сборщик мусора (Garbage Collector)

Go использует автоматический сборщик мусора, который:
Работает параллельно с программой
Минимизирует паузы (low-latency GC)
Очищает неиспользуемые объекты из кучи

import "runtime"

runtime.GC() // Принудительный запуск сборщика мусора (обычно не нужно)

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

🤔 Зачем нужны линтеры (linters)?

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

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

🤔 Как расшифровывается аббревиатура ACID?

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

🚩ACID

🟠A (Atomicity) — Атомарность
Транзакция выполняется либо полностью, либо не выполняется вовсе.
Пример: Если при переводе денег со счета A на счет B ошибка произошла на полпути, изменения откатываются.

🟠C (Consistency) — Согласованность
Данные остаются в правильном состоянии до и после транзакции.
Пример: Если сумма на всех счетах банка должна оставаться неизменной, транзакция не должна нарушить это правило.

🟠I (Isolation) — Изолированность
Одновременные транзакции не мешают друг другу.
Пример: Два клиента покупают один и тот же товар, но база данных правильно обрабатывает, кто купил первым.

🟠D (Durability) — Долговечность
После завершения транзакции изменения сохраняются, даже если система сломается.
Пример: Если заказ оформлен, он не исчезнет при внезапном отключении электричества.

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