Цели главы
- Запускать горутины и правильно дожидаться их через
WaitGroup. - Понимать небуферизованные и буферизованные каналы,
closeиrangeпо каналу. - Ждать нескольких событий и таймаутов через
select. - Защищать общие данные мьютексом и писать worker pool.
- Отменять работу через
context.
Горутины
Как GoFlix одновременно грузит обложки, считает рекомендации и стримит фильмы тысячам пользователей? Go создавали для многопоточности, но вместо тяжёлых потоков операционной системы в нём горутины: лёгкие, стартуют с маленьким стеком в пару килобайт, который растёт по мере необходимости. Запускаются словом go и управляются планировщиком Go.
Планировщик работает по схеме M:N: множество горутин распределяется на меньшее число потоков ОС, и Go сам переключает их. Поэтому тысячи горутин почти ничего не стоят по памяти и эффективно загружают все ядра процессора.
main — тоже горутина
Когда main завершается, программа заканчивается вместе со всеми горутинами — даже незаконченными. Если main закончится слишком быстро, вывод горутин может вообще не появиться.
package main
import (
"fmt"
"time"
)
func main() {
go fmt.Println("привет из горутины")
go func() {
fmt.Println("привет из анонимной горутины")
}()
time.Sleep(100 * time.Millisecond) // только для демонстрации
fmt.Println("main завершается")
// недетерминированный вывод: порядок первых двух строк может меняться
}Пример вывода:
привет из анонимной горутины
привет из горутины
main завершаетсяsync.WaitGroup
WaitGroup — счётчик активных горутин:
wg.Add(1)— увеличить счётчик перед запуском горутины;wg.Done()— уменьшить, когда горутина закончила; обычно черезdefer;wg.Wait()— заблокировать вызывающую горутину, пока счётчик не станет нулём.
package main
import (
"fmt"
"sync"
"time"
)
func main() {
movies := []string{"Интерстеллар", "Дюна", "Начало"}
var wg sync.WaitGroup
for i, movie := range movies {
wg.Add(1) // до запуска горутины
go func() {
defer wg.Done() // уменьшит счётчик при любом выходе
time.Sleep(time.Duration(30*(len(movies)-i)) * time.Millisecond)
fmt.Println("загружен постер:", movie)
}()
}
wg.Wait() // ждём, пока все горутины не закончат
fmt.Println("все постеры загружены")
// недетерминированный вывод: кто закончил раньше, тот и печатает
}Пример вывода:
загружен постер: Начало
загружен постер: Дюна
загружен постер: Интерстеллар
все постеры загруженыГорутины работают конкурентно, поэтому сообщения появляются в порядке завершения, а не запуска. Главное — wg.Wait() после цикла: дальше main пойдёт только после всех Done.
Каналы
Go предлагает обмениваться данными через каналы — по девизу «Не общайтесь через разделяемую память — разделяйте память через общение». Канал типизирован: по chan string ходят только строки.
- Создать:
ch := make(chan string). - Отправить:
ch <- v. Получить:v := <-ch. - В небуферизованном канале отправка блокирует горутину, пока другая не прочитает значение, а чтение блокирует, пока значение не отправят. Отправитель и получатель встречаются в одной точке синхронизации.
package main
import "fmt"
func average(ratings []float64) float64 {
sum := 0.0
for _, r := range ratings {
sum += r
}
return sum / float64(len(ratings))
}
func main() {
messages := make(chan string) // небуферизованный канал строк
go func() {
messages <- "Матрица загружена" // отправка ждёт, пока кто-то прочитает
}()
fmt.Println(<-messages) // чтение ждёт, пока кто-то отправит
avgCh := make(chan float64)
go func() {
avgCh <- average([]float64{8.7, 9.0, 8.1})
}()
fmt.Printf("средний рейтинг: %.2f\n", <-avgCh)
}Матрица загружена
средний рейтинг: 8.60Канал в Go — не просто контейнер, а способ безопасно передать значение и одновременно синхронизировать горутины.
Буферизованный канал
Если отправителю не нужно ждать получателя на каждом сообщении, канал создают с буфером: make(chan T, N). Отправка блокируется, только когда буфер полон, чтение — когда пуст. По сути, это небольшая очередь: отправитель может «забежать вперёд». Удобно, когда сообщения приходят пачками.
package main
import "fmt"
func main() {
notifications := make(chan string, 3)
notifications <- "Новый фильм: Дюна 2"
notifications <- "Скидка 50%!"
notifications <- "Новый сезон: Мандалорец"
// notifications <- "ещё одно" — заблокировало бы: буфер полон
fmt.Println(len(notifications), "из", cap(notifications), "в очереди")
fmt.Println(<-notifications)
fmt.Println(<-notifications)
fmt.Println(len(notifications), "в очереди")
}3 из 3 в очереди
Новый фильм: Дюна 2
Скидка 50%!
1 в очередиclose и range по каналу
close(ch) сообщает получателям: значений больше не будет.
- Цикл
for v := range chчитает, пока канал не закрыт и не пуст, а потом сам завершается. Уже отправленные значения закрытие не удаляет. - Чтение из закрытого и пустого канала возвращает нулевое значение и
ok == false. - Отправка в закрытый канал — паника
send on closed channel. - Закрывает канал только отправитель, получатель — никогда.
package main
import "fmt"
func main() {
moviesCh := make(chan string)
go func() {
defer close(moviesCh) // закрывает отправитель: «данных больше не будет»
for _, m := range []string{"Матрица", "Начало", "Довод"} {
moviesCh <- m
}
}()
for movie := range moviesCh { // цикл завершится после close
fmt.Println("получен:", movie)
}
done := make(chan int)
close(done)
val, ok := <-done // закрытый и пустой: нулевое значение и false
fmt.Println("значение:", val, "открыт?", ok)
}получен: Матрица
получен: Начало
получен: Довод
значение: 0 открыт? falsepackage main
func main() {
ch := make(chan int, 1)
close(ch)
ch <- 1 // ожидается panic
}panic: send on closed channelЕсли отправителей несколько, закрывать канал можно только когда все закончили отправку — для этого WaitGroup и отдельная горутина, которая закроет канал после wg.Wait():
package main
import (
"fmt"
"slices"
"sync"
)
func main() {
results := make(chan string)
var wg sync.WaitGroup
for _, film := range []string{"Дюна", "Матрица", "Начало"} {
wg.Add(1)
go func() {
defer wg.Done()
results <- film + ": обложка готова"
}()
}
go func() {
wg.Wait() // все отправители закончили
close(results) // теперь закрывать безопасно
}()
var all []string
for r := range results {
all = append(all, r)
}
slices.Sort(all) // горутины финишируют в любом порядке
fmt.Println(all)
}[Дюна: обложка готова Матрица: обложка готова Начало: обложка готова]Сигнальный канал
Если передавать данные не нужно, а важен сам факт события — «работа закончена», «пора остановиться», — используют канал пустых структур chan struct{}. Сигнал — отправка struct{}{} или закрытие канала. Закрытие удобнее: его «услышат» сразу все ждущие горутины.
package main
import (
"fmt"
"time"
)
func main() {
done := make(chan struct{}) // данных нет — важен только сигнал
go func() {
fmt.Println("горутина работает...")
time.Sleep(50 * time.Millisecond)
close(done) // сигнал всем, кто ждёт
}()
<-done
fmt.Println("main: получили сигнал завершения")
}горутина работает...
main: получили сигнал завершенияselect
select похож на switch, но для каналов: ждёт, пока один из каналов будет готов, и выполняет его case.
- Готовы несколько — выбирается случайный.
- Не готов ни один и нет
default—selectблокируется. defaultделаетselectнеблокирующим: если данных нет, сразу идём дальше.time.After(d)— канал, в который придёт значение черезd: так ограничивают время ожидания.
package main
import (
"fmt"
"time"
)
func fetch(delay time.Duration, movie string) <-chan string {
ch := make(chan string, 1) // буфер 1: горутина не зависнет, если результат не прочитают
go func() {
time.Sleep(delay)
ch <- movie
}()
return ch
}
func main() {
select {
case movie := <-fetch(50*time.Millisecond, "Интерстеллар"):
fmt.Println("рекомендация:", movie)
case <-time.After(200 * time.Millisecond):
fmt.Println("таймаут: сервис рекомендаций не ответил")
}
select {
case movie := <-fetch(300*time.Millisecond, "Дюна"):
fmt.Println("рекомендация:", movie)
case <-time.After(100 * time.Millisecond):
fmt.Println("таймаут: сервис рекомендаций не ответил")
}
empty := make(chan string)
select {
case msg := <-empty:
fmt.Println(msg)
default:
fmt.Println("данных нет — идём дальше") // default делает select неблокирующим
}
}рекомендация: Интерстеллар
таймаут: сервис рекомендаций не ответил
данных нет — идём дальшеselect без default — когда действительно нужно дождаться одного из событий; с default — когда нужно проверить каналы и не ждать.
sync.Mutex
Иногда удобнее не передавать данные, а защитить общий ресурс. sync.Mutex (взаимное исключение) гарантирует, что с ресурсом работает только одна горутина, а остальные ждут. Lock() — вход в критическую секцию, Unlock() — выход; defer Unlock() сразу после Lock() освободит мьютекс при любом выходе, даже при панике.
package main
import (
"fmt"
"sync"
)
// ViewCounter — потокобезопасный счётчик просмотров.
type ViewCounter struct {
mu sync.Mutex
count int
}
func (vc *ViewCounter) Increment() {
vc.mu.Lock()
defer vc.mu.Unlock() // освободим при любом выходе
vc.count++
}
func (vc *ViewCounter) Value() int {
vc.mu.Lock()
defer vc.mu.Unlock()
return vc.count
}
func main() {
counter := &ViewCounter{}
var wg sync.WaitGroup
for range 1000 {
wg.Add(1)
go func() {
defer wg.Done()
counter.Increment()
}()
}
wg.Wait()
fmt.Println("просмотров:", counter.Value())
}просмотров: 1000Даже чтение защищено мьютексом, чтобы получить согласованное значение. Без мьютекса несколько горутин одновременно читали бы и меняли одно поле — это гонка данных (data race), и итог мог бы оказаться меньше 1000.
Worker Pool
Задач много, но запускать горутину на каждую — плохая идея: можно перегрузить базу или внешний сервис. Worker pool — фиксированное число горутин-воркеров, которые берут задачи из канала jobs и кладут результаты в results. Отправив все задачи, канал jobs закрывают: когда он опустеет, цикл range у каждого воркера завершится. Паттерн ограничивает число одновременных операций и упрощает контроль ресурсов.
package main
import (
"fmt"
"time"
)
// worker обрабатывает задачи из jobs, пока канал не закрыт и не пуст.
func worker(id int, jobs <-chan string, results chan<- string) {
for film := range jobs {
time.Sleep(10 * time.Millisecond) // «обработка»
results <- fmt.Sprintf("воркер %d обработал: %s", id, film)
}
}
func main() {
films := []string{"Дюна", "Матрица", "Довод", "Начало", "Аватар"}
jobs := make(chan string, len(films))
results := make(chan string, len(films))
for w := 1; w <= 3; w++ { // ровно три воркера, сколько бы ни было задач
go worker(w, jobs, results)
}
for _, f := range films {
jobs <- f
}
close(jobs) // сигнал: задач больше не будет
for range films { // столько чтений, сколько задач
fmt.Println(<-results)
}
// недетерминированный вывод: какой воркер что взял — решает планировщик
}Пример вывода:
воркер 3 обработал: Дюна
воркер 1 обработал: Матрица
воркер 2 обработал: Довод
воркер 2 обработал: Аватар
воркер 3 обработал: НачалоПорядок результатов каждый раз разный: кто из воркеров быстрее закончил, тот раньше и отправил результат. Типы <-chan string и chan<- string — каналы только для чтения и только для записи: компилятор не даст воркеру случайно писать в jobs.
context — отмена и дедлайны
В реальных сервисах работу приходится отменять: пользователь ушёл, истёк таймаут, запрос отменили. Пакет context передаёт сигнал отмены и дедлайн.
| Функция | Когда контекст отменится |
|---|---|
context.WithCancel(parent) |
при вызове cancel() или отмене родителя |
context.WithTimeout(parent, d) |
через время d |
context.WithDeadline(parent, t) |
в момент времени t |
ctx.Done() возвращает канал, который закрывается при отмене; ctx.Err() объясняет причину: context canceled или context deadline exceeded. Функция cancel вызывается всегда, обычно через defer, — она освобождает ресурсы контекста.
package main
import (
"context"
"fmt"
"sync"
"time"
)
func slowRecommendations(ctx context.Context, delay time.Duration) (string, error) {
select {
case <-time.After(delay): // «долгая» работа
return "Интерстеллар, Дюна", nil
case <-ctx.Done(): // отмена или дедлайн
return "", ctx.Err()
}
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel() // освобождаем ресурсы контекста в любом случае
res, err := slowRecommendations(ctx, 50*time.Millisecond)
fmt.Println("успели:", res, err)
res, err = slowRecommendations(ctx, 300*time.Millisecond)
fmt.Printf("не успели: %q, %v\n", res, err)
ctx2, cancel2 := context.WithCancel(context.Background())
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
for {
select {
case <-ctx2.Done():
fmt.Println("стриминг остановлен:", ctx2.Err())
return
default:
time.Sleep(20 * time.Millisecond) // «стримим» кусок фильма
}
}
}()
time.Sleep(70 * time.Millisecond)
cancel2() // ручная отмена — горутина завершится
wg.Wait()
}успели: Интерстеллар, Дюна <nil>
не успели: "", context deadline exceeded
стриминг остановлен: context canceledcontext не просто ждёт завершения задачи, а управляет её жизненным циклом: останавливает по таймауту, по дедлайну или по команде. В бэкенде контекст передают первым параметром во все функции, которые ходят в сеть или в базу, — см. 19 — Работа с базами данных → Context во всём приложении.
Итоги
| Инструмент | Зачем | Ключевые детали |
|---|---|---|
| Горутина | лёгкая конкурентная функция | go f(), стек от пары КБ, планировщик M:N |
sync.WaitGroup |
дождаться группы горутин | Add до запуска, defer Done, Wait до нуля |
| Канал | безопасный обмен данными | небуферизованный — встреча; буферизованный — очередь |
close и range |
конец потока данных | закрывает отправитель; запись в закрытый — паника |
select |
ждать несколько каналов | случайный из готовых; default — без ожидания |
sync.Mutex |
защитить общие данные | Lock + defer Unlock |
| Worker pool | ограничить параллелизм | N воркеров читают jobs, пишут results |
context |
отмена и дедлайны | WithCancel, WithTimeout, Done(), Err() |
Практика
Домашнее задание
- Параллельная проверка эпизодов. Функция
checkEpisode(title string, delay int, wg *sync.WaitGroup)имитирует проверку черезtime.Sleepи сообщает, что эпизод готов к публикации. Запусти горутину на каждый эпизод, дождись всех черезWaitGroupи выведи, что все эпизоды проверены. - Статусы транскодирования через канал. Функция
transcodeVideo(name string, ch chan string)имитирует транскодирование и отправляет в канал строку-результат. Запусти горутину на каждый файл, собери результаты из канала и выведи. Безtime.Sleepдля ожидания. - Очередь событий плеера. Буферизованный канал строк, события
play,pause,seek,stop. Отправь все, закрой канал, прочитай цикломfor range, в конце сообщи, что очередь обработана. - Предпочтения с таймаутом.
loadUserTasteпосле задержки отправляет в канал описание предпочтений. Черезselectлибо получи результат, либо по таймауту сообщи, что предпочтения пока недоступны. - Мини-аналитика. События: просмотр начат, остановлен, завершён, лайк поставлен, добавлено в избранное. Канал
jobs, каналresults, несколько воркеров; закройjobsпосле отправки, собери результаты, дождись воркеров черезWaitGroup; посчитай обработанные события под мьютексом; добавьcontext.WithTimeoutи, если время вышло, прекрати обработку и сообщи об отмене.
решениеЭталонное решение
Задание 1 — порядок завершения эпизодов зависит от задержек и планировщика:
package main
import (
"fmt"
"sync"
"time"
)
func checkEpisode(title string, delay int, wg *sync.WaitGroup) {
defer wg.Done()
time.Sleep(time.Duration(delay) * time.Millisecond) // имитация проверки
fmt.Printf("эпизод %q готов к публикации\n", title)
}
func main() {
episodes := map[string]int{"Пилот": 30, "Эпизод 2": 10, "Финал": 20}
var wg sync.WaitGroup
for title, delay := range episodes {
wg.Add(1)
go checkEpisode(title, delay, &wg)
}
wg.Wait()
fmt.Println("все эпизоды проверены успешно")
// недетерминированный вывод: эпизоды завершаются в разном порядке
}Пример вывода:
эпизод "Эпизод 2" готов к публикации
эпизод "Финал" готов к публикации
эпизод "Пилот" готов к публикации
все эпизоды проверены успешноЗадания 2–5:
package main
import (
"context"
"errors"
"fmt"
"slices"
"strings"
"sync"
"time"
)
// Задание 2: транскодирование, результаты через канал.
func transcodeVideo(name string, ch chan<- string) {
time.Sleep(time.Duration(len(name)) * time.Millisecond) // имитация работы
ch <- name + " → 1080p готово"
}
// Задание 4: предпочтения пользователя с задержкой.
func loadUserTaste(delay time.Duration, ch chan<- string) {
time.Sleep(delay)
ch <- "любит фантастику и триллеры"
}
func waitTaste(delay, timeout time.Duration) {
ch := make(chan string, 1) // буфер: горутина не зависнет после таймаута
go loadUserTaste(delay, ch)
select {
case taste := <-ch:
fmt.Println("предпочтения:", taste)
case <-time.After(timeout):
fmt.Println("предпочтения пользователя пока недоступны")
}
}
// Задание 5: аналитика — worker pool, мьютекс и context.
type stats struct {
mu sync.Mutex
processed int
}
func (s *stats) inc() {
s.mu.Lock()
defer s.mu.Unlock()
s.processed++
}
func runAnalytics(timeout time.Duration, events []string) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
jobs := make(chan string, len(events))
results := make(chan string, len(events))
var st stats
var wg sync.WaitGroup
for range 2 { // два воркера
wg.Add(1)
go func() {
defer wg.Done()
for ev := range jobs {
select {
case <-ctx.Done():
return // время вышло — прекращаем обработку
case <-time.After(20 * time.Millisecond): // «обработка» события
st.inc()
results <- "обработано: " + ev
}
}
}()
}
for _, ev := range events {
jobs <- ev
}
close(jobs)
wg.Wait() // после Wait все воркеры закончили — читать st безопасно
close(results)
var done []string
for r := range results {
done = append(done, r)
}
slices.Sort(done)
for _, r := range done {
fmt.Println(r)
}
if err := ctx.Err(); errors.Is(err, context.DeadlineExceeded) {
fmt.Println("обработка отменена:", err)
}
fmt.Printf("событий обработано: %d из %d\n", st.processed, len(events))
}
func main() {
// 2
files := []string{"trailer.mp4", "episode-01.mkv", "teaser.mov"}
ch := make(chan string)
for _, f := range files {
go transcodeVideo(f, ch)
}
var statuses []string
for range files { // ровно столько чтений, сколько отправок — без time.Sleep
statuses = append(statuses, <-ch)
}
slices.Sort(statuses)
fmt.Println(strings.Join(statuses, "\n"))
// 3
events := make(chan string, 4)
for _, e := range []string{"play", "pause", "seek", "stop"} {
events <- e
}
close(events)
for e := range events {
fmt.Println("событие плеера:", e)
}
fmt.Println("очередь событий обработана")
// 4
waitTaste(10*time.Millisecond, 200*time.Millisecond)
waitTaste(300*time.Millisecond, 50*time.Millisecond)
// 5
analytics := []string{"просмотр начат", "просмотр остановлен", "просмотр завершён",
"лайк поставлен", "добавлено в избранное"}
runAnalytics(time.Second, analytics)
runAnalytics(5*time.Millisecond, analytics)
}episode-01.mkv → 1080p готово
teaser.mov → 1080p готово
trailer.mp4 → 1080p готово
событие плеера: play
событие плеера: pause
событие плеера: seek
событие плеера: stop
очередь событий обработана
предпочтения: любит фантастику и триллеры
предпочтения пользователя пока недоступны
обработано: добавлено в избранное
обработано: лайк поставлен
обработано: просмотр завершён
обработано: просмотр начат
обработано: просмотр остановлен
событий обработано: 5 из 5
обработка отменена: context deadline exceeded
событий обработано: 0 из 5Тренировка: предскажи вывод
package main
import "fmt"
func main() {
ch := make(chan int, 2)
ch <- 1
ch <- 2
close(ch)
for v := range ch {
fmt.Print(v, " ")
}
v, ok := <-ch
fmt.Println(v, ok)
}самопроверкаОтвет
1 2 0 falseЗакрытый канал отдаёт всё, что успели положить в буфер, и только потом range завершается. Дальнейшее чтение — нулевое значение и false.
Проверь себя
вопросЧем горутина отличается от потока ОС?
Горутина намного легче: стартует со стеком в пару килобайт, который растёт, и переключается планировщиком Go, а не ядром ОС. Тысячи горутин работают на нескольких потоках — модель M:N.
вопросЧто произойдёт с горутинами, когда завершится main?
Программа закончится, и все горутины будут остановлены, даже незаконченные. Их нужно явно дождаться.
вопросКак правильно использовать WaitGroup?
Add(1) до запуска горутины, defer wg.Done() внутри неё, Wait() там, где нужно дождаться. Передавать — по указателю.
вопросЧем небуферизованный канал отличается от буферизованного?
В небуферизованном отправка и получение блокируют друг друга до встречи. В буферизованном отправка не блокируется, пока буфер не полон, а получение — пока он не пуст.
вопросКто закрывает канал и что будет при отправке в закрытый?
Закрывает отправитель. Отправка в закрытый канал — паника; чтение из закрытого и пустого — нулевое значение и ok == false.
вопросЧто делает select, если готовы несколько каналов? А если ни одного?
Выбирает случайный из готовых. Если не готов ни один: с default выполняет его, без default — блокируется.
вопросЗачем нужен worker pool?
Чтобы ограничить число одновременных операций — фиксированное число воркеров обрабатывает задачи из канала — и не перегрузить ресурсы.
вопросЧто такое context и почему cancel вызывают через defer?
Механизм передачи отмены и дедлайна. cancel освобождает ресурсы контекста; если не вызвать — утечка до истечения таймаута или отмены родителя.
вопросКак найти гонку данных?
Запустить программу или тесты с флагом -race.
Ключевые выводы
- 🪶 Горутины лёгкие:
go f(), стек от пары килобайт, планировщик M:N. - ⏱️ Ждать горутины нужно явно:
WaitGroupили каналы, а неSleep. - 📨 Канал — типизированная труба и точка синхронизации; закрывает только отправитель.
- 🔀
selectждёт несколько каналов,time.Afterдаёт таймаут,default— неблокирующую проверку. - 🔐
Mutexзащищает общие данные; гонки ищет флаг-race. - 🏭 Worker pool ограничивает параллелизм,
contextотменяет работу по таймауту или команде.
