❓ Есть ли в Go механизм для автоматического переключения контекста между горутинами

Планировщик Go автоматически управляет переключением контекста между горутинами, чтобы они могли эффективно выполняться на доступных системных потоках. Однако, если вы хотите «подсказать» планировщику, когда нужно приостановить текущую горутину в пользу другой, можно использовать функцию runtime.Gosched().

Предположим, у нас есть две горутины: одна выполняет сложные вычисления, а другая просто выводит текст. Если горутина с вычислениями вызывает runtime.Gosched(), планировщик может переключиться на горутину, которая выводит текст, давая ей шанс быстрее завершить свою работу.

Пример:

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Вычисления:", i)
            runtime.Gosched()  // Подсказка планировщику для переключения
        }
    }()

    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Печать текста:", i)
            time.Sleep(10 * time.Millisecond)
        }
    }()

    time.Sleep(1 * time.Second)
}

➡️ Работа планировщика
Горутины планируются и выполняются в порядке их готовности (FIFO). Исполнение горутины может быть прервано, если она блокируется, например, при системном вызове или при использовании синхронизирующих объектов. Однако горутины не имеют квантов времени — они не возвращаются в очередь автоматически. Для этого нужно вручную вызвать runtime.Gosched().

➡️ Иногда стоит использовать runtime.Gosched(), чтобы долгоживущие горутины не задерживали выполнение других горутин. Это позволяет улучшить отклик приложения, особенно в случае, когда требуется выполнить несколько задач параллельно, и важно избежать блокировки.

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

❓ Какие задачи можно решить с помощью конструкции ‘…’ в Go

Синтаксическая конструкция ‘…’ в Go используется в нескольких контекстах, в частности для:

1️⃣Определение функции с переменным количеством аргументов (вариативная функция)
Она позволяет функции принимать неопределенное количество аргументов одного типа.
Синтаксис: параметр функции определяется с использованием ... перед типом.

func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

2️⃣Передача среза как отдельных аргументов функции
Когда вы хотите передать все элементы среза как отдельные аргументы функции, используется ... .
Синтаксис: при вызове функции с срезом используется ... после имени среза.

nums := []int{1, 2, 3, 4}
fmt.Println(sum(nums...)) // Вывод: 10

3️⃣Определение массивов с неизвестной заранее длиной
Когда необходимо создать массив, длина которого будет определена на основе количества элементов.
Синтаксис: при инициализации массива используется ... вместо явного указания длины.

x := [...]int{1, 2, 3}// Go определит длину массива автоматически

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

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

1️⃣Неиспользуемая локальная переменная

• Если вы объявляете локальную переменную, но не используете её в коде, это приведет к ошибке компиляции.

package main

import "fmt"

func main() {
    x := 10
    fmt.Println("Hello, World!")
}

Компилятор выдаст ошибку: x declared but not used

2️⃣Неиспользуемое возвращаемое значение

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

package main

import "errors"

func doSomething() (int, error) {
    return 42, errors.New("an error occurred")
}

func main() {
    doSomething() // Это допустимо
    result, err := doSomething() // 
}

Это вызовет ошибку, так как result и err не используются

3️⃣Неиспользуемый импорт

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

package main

import "math"

func main() {
    // Ничего не делаем
}

Компилятор выдаст ошибку: "math" imported and not used.

❕Исключения

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

package main

import "fmt"

var globalVar int

func greet(name string, age int) {
    fmt.Println("Hello,", name)
}

func main() {
    greet("Alice", 25)
    fmt.Println("Hello, World!")
}

Глобальная переменная globalVar не используется, но код скомпилируется без ошибок.

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