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

В многопоточных (параллельных) программах горутины (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)
}

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

🤔 Что такое хэш-коллизия?

Хэш-коллизия возникает, когда два разных ключа имеют одинаковое хэш-значение. Это проблема, так как Map должен хранить уникальные ключи. Для её разрешения используются методы, такие как цепочки (chaining) или открытая адресация (open addressing).

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

🤔 Какие есть особенности синтаксиса получения и записи значений в 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)
        }
    }

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

🤔 Что такое тип rune? Зачем их использовать?

rune — это псевдоним для int32, который представляет один символ Unicode. Используется для работы с многоязычными текстами и символами, особенно когда требуется обработка не-ASCII символов. Это полезно в случаях, когда нужно обрабатывать строки на уровне символов, а не байтов.

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

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

Создание дочернего контекста данных в Go предоставляет мощные возможности для управления временем выполнения операций, отмены и передачи метаданных.

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

ctx, cancel := context.WithTimeout(parentCtx, 2*time.Second)
defer cancel()

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

deadline := time.Now().Add(5 * time.Second)
ctx, cancel := context.WithDeadline(parentCtx, deadline)
defer cancel()

🟠Явная отмена операций
Контексты позволяют явно отменять операции, что полезно для управления горутинами и предотвращения утечек памяти.
context.WithCancel создает контекст, который может быть отменен вручную с помощью функции cancel.

ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

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

type key string
ctx := context.WithValue(parentCtx, key("userID"), 12345)

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

ctx1, cancel1 := context.WithCancel(parentCtx)
ctx2, cancel2 := context.WithTimeout(ctx1, 1*time.Second)
defer cancel1()
defer cancel2()

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

var wg sync.WaitGroup
ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

wg.Add(2)
go func() {
    defer wg.Done()
    worker(ctx, "Worker 1")
}()
go func() {
    defer wg.Done()
    worker(ctx, "Worker 2")
}()
wg.Wait()

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "stopped")
            return
        default:
            fmt.Println(name, "working")
            time.Sleep(1 * time.Second)
        }
    }
}

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

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    select {
    case <-time.After(5 * time.Second):
        fmt.Fprintln(w, "Request processed")
    case <-ctx.Done():
        err := ctx.Err()
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)

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

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

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

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

🤔 Как слайсы работают?

Слайс (slice) — это динамический массив, который ссылается на часть массива в памяти. В отличие от массивов (array), слайсы могут изменять размер.

🚩Внутреннее устройство слайса

Слайс в Go — это структура

type SliceHeader struct {
    Data uintptr // Указатель на массив в памяти
    Len  int     // Длина слайса (количество элементов)
    Cap  int     // Вместимость (capacity) — сколько элементов может вместить без перевыделения памяти
}

Пример структуры слайса

arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4] // Берём срез от 2-го до 4-го элемента
fmt.Println(s) // [2 3 4]

🚩Создание слайсов

Есть несколько способов создать слайс:
Способ 1: Срез массива

arr := [5]int{10, 20, 30, 40, 50}
s := arr[1:4] // [20 30 40]

Способ 2: Использование make()

s := make([]int, 3, 5) // Длина 3, вместимость 5
fmt.Println(s, len(s), cap(s)) // [0 0 0] 3 5

Способ 3: Литерал (инициализация значениями)

s := []int{1, 2, 3}
fmt.Println(s) // [1 2 3]

🚩Изменение слайса

Слайсы можно изменять, используя append().

s := []int{1, 2, 3}
s = append(s, 4, 5)
fmt.Println(s) // [1 2 3 4 5]

🚩Как растёт `slice`?

Когда append() увеличивает slice, Go использует оптимизированный алгоритм роста:
- Если cap < 1024, слайс удваивает размер (cap *= 2).
- Если cap >= 1024, рост идёт примерно на 25% (cap += cap / 4).

s := []int{}
for i := 0; i < 10; i++ {
    s = append(s, i)
    fmt.Printf("Len: %d, Cap: %d\n", len(s), cap(s))
}

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

Len: 1, Cap: 1
Len: 2, Cap: 2
Len: 3, Cap: 4
Len: 5, Cap: 8
Len: 9, Cap: 16

🚩Как избежать неожиданных эффектов?

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

arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[:3] // [1 2 3]
s2 := arr[2:] // [3 4 5]
s2[0] = 100    // Меняем первый элемент s2

fmt.Println(s1) // [1 2 100] ❗️ s1 тоже изменился

Решение: используйте copy() для создания нового массива.

s1 := []int{1, 2, 3}
s2 := make([]int, len(s1))
copy(s2, s1) // Копируем данные
s2[0] = 100
fmt.Println(s1) // [1 2 3] ✅ Оригинал не изменился

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

🤔 Как можно обработать панику с помощью defer и recover?

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

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

🤔 Какое свойство должно быть у ключа в Map?

Ключи в map (карте) должны обладать определенными свойствами, чтобы быть допустимыми и корректно работать с хеш-таблицей. Важно понимать, что ключи должны поддерживать операцию сравнения и быть хешируемыми.

🚩Свойства ключей

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

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

🚩Допустимые типы ключей

Булевый тип (bool)

  m := map[bool]string{
    true:  "Yes",
    false: "No",
}  

Целочисленные типы (int, int8, int16, int32, int64, а также их беззнаковые эквиваленты uint, uint8, uint16, uint32, uint64)

  m := map[int]string{
    1: "One",
    2: "Two",
}  

Числа с плавающей точкой (float32, float64)

  m := map[float64]string{
    1.1: "One point one",
    2.2: "Two point two",
}  

Строки (string)

  m := map[string]int{
    "Alice": 25,
    "Bob":   30,
}

Составные типы (структуры, массивы), при условии, что все их поля также поддерживают сравнение с помощью оператора ==

  type Key struct {
    FirstName string
    LastName  string
}

m := map[Key]int{
    {"Alice", "Smith"}: 1,
    {"Bob", "Johnson"}: 2,
}
  

🚩Недопустимые типы ключей

🟠Срезы (slice)
Срезы не поддерживают операцию сравнения с использованием оператора == (только сравнение с nil).
🟠Карты (map)
Карты не поддерживают операцию сравнения.
🟠Функции (func)
Функции не поддерживают операцию сравнения.

package main

import "fmt"

type Person struct {
    FirstName string
    LastName  string
}

func main() {
    // Создаем карту с ключами типа Person
    m := make(map[Person]int)

    // Вставляем значения в карту
    m[Person{"Alice", "Smith"}] = 25
    m[Person{"Bob", "Johnson"}] = 30

    // Выводим значения из карты
    fmt.Println(m[Person{"Alice", "Smith"}])  // Выводит: 25
    fmt.Println(m[Person{"Bob", "Johnson"}])  // Выводит: 30
}

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

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

1. Мьютексы для блокировки критических секций.
2. Каналы для организации потокобезопасного взаимодействия.
3. WaitGroup для ожидания завершения нескольких горутин.
4. Атомарные операции для управления простыми данными.

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

🤔 Что будет если сложить строки?

В Go строки представляют собой неизменяемые последовательности байтов, и операция сложения строк (+) приводит к созданию новой строки, которая является конкатенацией двух или более исходных строк.

🚩Что произойдет при сложении строк?

🟠Создание новой строки
Когда вы складываете строки, Go создает новую строку, содержащую все символы исходных строк, соединенных друг за другом. Исходные строки при этом остаются неизменными.

s1 := "Hello"
s2 := "World"
result := s1 + " " + s2
fmt.Println(result) // Output: Hello World

🟠Новая строка размещается в памяти
Так как строки в Go неизменяемы, результирующая строка создается заново, а память для нее выделяется в куче или на стеке, в зависимости от размера и контекста.

🚩Особенности сложения строк в Go

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

result := ""
for i := 0; i < 5; i++ {
    result += "Go"
}
fmt.Println(result) // Output: GoGoGoGoGo

🟠Использование `strings.Builder` для оптимизации
Если требуется объединить много строк, рекомендуется использовать strings.Builder. Это более эффективный способ, так как Builder работает с буфером и избегает лишних аллокаций.

   import "strings"

   func main() {
       var builder strings.Builder
       for i := 0; i < 5; i++ {
           builder.WriteString("Go")
       }
       fmt.Println(builder.String()) // Output: GoGoGoGoGo
   }
   

🚩Особенности Unicode

Go строки поддерживают Unicode, поэтому сложение строк корректно работает с многобайтовыми символами.

s1 := "Привет"
s2 := "Мир"
result := s1 + " " + s2
fmt.Println(result) // Output: Привет Мир

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

🤔 Какова осведомлённость о сборщике мусора в Go?

Go имеет встроенный, автоматический сборщик мусора, поэтому разработчик не управляет памятью вручную. Однако понимание его работы важно:
- GC запускается в фоновом режиме.
- Поддерживается пауза менее миллисекунды для большинства случаев (начиная с Go 1.8 и выше).
- Поведение GC можно настраивать через переменную окружения GOGC.
Сборщик ориентирован на низкую задержку, даже если это немного снижает throughput.

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

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

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

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

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

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

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

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

Из массива

    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]
}

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

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

1. context.Background:
- Основной контекст, используемый как корень.
2. context.WithCancel:
- Позволяет отменить выполнение всех дочерних контекстов.
3. context.WithTimeout:
- Устанавливает лимит времени на выполнение операций.
4. context.WithValue:
- Передача ключ-значений между горутинами.

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

🤔 Как устроена объектоориентированная модель?

Объектно-ориентированная модель отличается от традиционных ООП-языков, таких как C# или Java. Нет классов и наследования в привычном понимании. Вместо этого используются структуры (structs) и интерфейсы для реализации основных принципов ООП: инкапсуляции, композиции и полиморфизма.

🚩Концепции

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

type Person struct {
    Name string
    Age  int
}

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

func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

🟠Инкапсуляция
Достигается через модификаторы доступа на уровне пакета. Поля и методы, начинающиеся с заглавной буквы, экспортируемые (public), остальные — нет (private).

type Person struct {
    name string // неэкспортируемое поле
    Age  int    // экспортируемое поле
}

🟠Композиция
Go не поддерживает классическое наследование. Вместо этого используется композиция для включения функциональности одного типа в другой.

type Employee struct {
    Person
    Position string
}

🟠Интерфейсы
Используются для определения поведения. Типы могут реализовывать интерфейсы неявно, просто предоставляя методы, указанные в интерфейсе.

type Greeter interface {
    Greet()
}

func SayHello(g Greeter) {
    g.Greet()
}

type Person struct {
    Name string
}

func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

func main() {
    p := Person{Name: "John"}
    SayHello(p)
}

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

type Greeter interface {
    Greet()
}

func SayHello(g Greeter) {
    g.Greet()
}

type Robot struct {
    ID string
}

func (r Robot) Greet() {
    fmt.Printf("Greetings, I am robot %s\n", r.ID)
}

func main() {
    p := Person{Name: "John"}
    r := Robot{ID: "XJ-9"}

    SayHello(p)
    SayHello(r)
}

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

🤔 Что такое константы и можно ли их изменять?

Константы в Go — это неизменяемые значения, объявляемые с помощью ключевого слова const. Их нельзя изменить после определения.

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

🤔 В чем разница процесса и потока в рамках операционной системы?

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

🚩Процесс

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

🚩Поток (Thread)

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

🚩Основные различия

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

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

🟠Создание и управление
Создание нового процесса более ресурсоемко, чем создание потока внутри существующего процесса.

🟠Взаимодействие
Взаимодействие между процессами требует использования межпроцессного взаимодействия (IPC), такого как сокеты, разделяемая память, очереди сообщений и т. д. Потоки внутри процесса могут общаться друг с другом напрямую через общую память.

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

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

🤔 Какое поведение по умолчанию используется в Go при передаче в функцию?

В Go параметры по умолчанию передаются по значению. Это значит, что функция получает копию переменной, и любые изменения внутри функции не повлияют на оригинал.
Однако:
- Если передаётся указатель (*T), слайс, карта или канал, то содержимое может быть изменено.
- Структуры копируются целиком, если не передаются по указателю.

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

🤔 Что такое NAT?

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

🚩Основные типы

🟠Статический NAT (Static NAT):
Фиксированный сопоставление: Один внутренний IP-адрес сопоставляется с одним внешним IP-адресом. Используется, когда необходимо, чтобы устройство в локальной сети всегда было доступно под одним и тем же публичным IP-адресом. Например Веб-сервер, который должен быть доступен из интернета под фиксированным IP-адресом.

🟠Динамический NAT (Dynamic NAT):
Внутренние IP-адреса сопоставляются с пулом внешних IP-адресов. Когда внутреннее устройство инициирует соединение с интернетом, ему временно присваивается один из доступных внешних IP-адресов. Например, локальная сеть с большим количеством устройств, где не требуется фиксированный внешний IP-адрес для каждого устройства.

🟠Преобразование адресов и портов (PAT, Port Address Translation), также известный как Маскарадинг (Masquerading):
Несколько внутренних IP-адресов могут использовать один внешний IP-адрес, но различаются по номерам портов. Каждый внутренний IP-адрес и порт сопоставляется с уникальным внешним портом. Например, Домашние или офисные сети, где множество устройств выходят в интернет через один публичный IP-адрес.

🚩Зачем нужен

🟠Сохранение IP-адресов:
IPv4-адресов недостаточно для всех устройств, и NAT позволяет использовать один публичный IP-адрес для множества устройств.

🟠Безопасность:
Внутренние IP-адреса не видны извне, что усложняет потенциальным злоумышленникам попытки атак на внутренние устройства.

🟠Управление подключениями:
NAT позволяет администрировать и контролировать сетевой трафик, предоставляя возможности для управления доступом и приоритизацией трафика.

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

🟠Инициирование соединения:
Когда устройство в локальной сети (например, компьютер с IP-адресом 192.168.1.10) инициирует соединение с устройством в интернете, NAT изменяет исходящий IP-адрес и порт на внешний IP-адрес маршрутизатора и уникальный номер порта.

🟠Ответный трафик:
Когда ответный пакет возвращается, NAT использует таблицу сопоставлений, чтобы определить, к какому внутреннему устройству направить пакет, и изменяет внешний IP-адрес и порт обратно на внутренний IP-адрес и порт.

🚩Пример работы PAT

1⃣Внутренний компьютер с IP-адресом 192.168.1.10 и портом 12345 инициирует соединение.
2⃣NAT изменяет это на внешний IP-адрес 203.0.113.1 и порт 54321.
3⃣Ответный пакет от сервера приходит на IP-адрес 203.0.113.1 и порт 54321.
4⃣NAT преобразует это обратно в 192.168.1.10:12345 и отправляет пакет внутреннему компьютеру.

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

🤔 Как Go Map'ы сделать более потокобезопасными?

1. Синхронизация: используйте sync.Mutex или sync.RWMutex для защиты операций чтения и записи.
2. Специальные структуры: вместо обычных карт можно использовать потокобезопасные реализации, такие как sync.Map.
3. Избегание гонок данных: убедитесь, что к карте обращаются только из одного потока или через контролируемую синхронизацию.

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