Горутины (Goroutines) в Go: Общее описание и использование

Горутины (goroutines) — это легковесные, конкурентные функции в Go. Они позволяют выполнять несколько задач одновременно, не блокируя основной поток выполнения программы. Горутины являются ключевым элементом конкурентного программирования в Go и позволяют создавать высокопроизводительные и масштабируемые приложения.

Основные характеристики горутин:

Легковесность: Горутины занимают значительно меньше памяти, чем потоки операционной системы. Обычно горутина занимает всего несколько килобайт памяти.
Конкурентность: Горутины выполняются конкурентно, то есть несколько горутин могут выполняться одновременно.
Многозадачность: Go runtime управляет горутинами и переключается между ними, обеспечивая многозадачность.
Каналы (Channels): Горутины часто используются вместе с каналами для обмена данными и синхронизации.

Как создать горутину:

Чтобы создать горутину, просто добавьте ключевое слово go перед вызовом функции:

package main

import (
"fmt"
"time"
)

func sayHello(name string) {
fmt.Println("Hello,", name)
}

func main() {
go sayHello("Alice") // Запускаем sayHello в горутине
go sayHello("Bob") // Запускаем sayHello в другой горутине

time.Sleep(1 * time.Second) // Даем горутинам время на выполнение
fmt.Println("Main function finished")
}

В этом примере функция sayHello запускается в двух разных горутинах. Обратите внимание, что time.Sleep используется для того, чтобы дать горутинам время на выполнение, прежде чем основная функция завершится. Без time.Sleep основная функция может завершиться до того, как горутины успеют выполниться.

Синхронизация горутин с помощью каналов:

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

package main

import (
"fmt"
)

func sum(numbers []int, channel chan int) {
sum := 0
for _, number := range numbers {
sum += number
}
channel <- sum // Отправляем сумму в канал
}

func main() {
numbers := []int{1, 2, 3, 4, 5}

// Создаем канал для передачи данных типа int
channel := make(chan int)

// Запускаем горутину для вычисления суммы первой половины чисел
go sum(numbers[:len(numbers)/2], channel)

// Запускаем горутину для вычисления суммы второй половины чисел
go sum(numbers[len(numbers)/2:], channel)

// Получаем результаты из канала
sum1 := <-channel
sum2 := <-channel

fmt.Println("Sum1:", sum1)
fmt.Println("Sum2:", sum2)
fmt.Println("Total sum:", sum1+sum2)
}

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

Типы каналов:

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

Пример использования буферизованного канала:

package main

import (
"fmt"
"time"
)

func main() {
// Создаем буферизованный канал с размером буфера 2
channel := make(chan int, 2)

// Отправляем данные в канал
channel <- 1
channel <- 2

// Пытаемся отправить еще одно значение (заблокируется, так как буфер заполнен)
go func() {
channel <- 3
fmt.Println("Sent 3 to channel")
}()

time.Sleep(1 * time.Second) // Даем горутине время на выполнение

// Получаем данные из канала
fmt.Println("Received:", <-channel)
fmt.Println("Received:", <-channel)
fmt.Println("Received:", <-channel)
}

WaitGroup для синхронизации горутин:

sync.WaitGroup — это еще один способ синхронизации горутин. Он позволяет дождаться завершения группы горутин.

package main

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

func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // Уменьшаем счетчик WaitGroup при завершении горутины

fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second)
fmt.Printf("Worker %d done\n", id)
}

func main() {
var wg sync.WaitGroup

for i := 1; i <= 3; i++ {
wg.Add(1) // Увеличиваем счетчик WaitGroup
go worker(i, &wg)
}

wg.Wait() // Ожидаем завершения всех горутин
fmt.Println("All workers done")
}

В этом примере sync.WaitGroup используется для ожидания завершения трех горутин worker. wg.Add(1) увеличивает счетчик WaitGroup перед запуском каждой горутины. wg.Done() уменьшает счетчик WaitGroup при завершении каждой горутины. wg.Wait() блокирует основную функцию до тех пор, пока счетчик WaitGroup не станет равным нулю.

Преимущества использования горутин:

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

📑 Горутины (Goroutines) в Go: Общее описание и использование