Горутины в Go: как работают goroutine, WaitGroup, race condition и конкурентность

Что такое горутина в Golang

сделали шаг 1
потом шаг 2
потом шаг 3

package main
import (
"fmt"
"time"
)
func sayHello() {
fmt.Println("hello from goroutine")
}
func main() {
go sayHello()
time.Sleep(time.Second)
}

go sayHello()

Что такое конкурентность в Go

Concurrency — управляем несколькими задачами.
Parallelism — реально выполняем несколько задач одновременно.

Почему goroutine — одна из главных фишек Golang

go processRequest(req)

Goroutine vs thread: чем горутина отличается от потока

Thread — поток операционной системы.
Goroutine — задача внутри runtime Go.

Как устроены горутины: модель GMP

go worker()

много G выполняются на нескольких M через P

Как запустить goroutine

package main
import "fmt"
func printMessage() {
fmt.Println("message")
}
func main() {
go printMessage()
}

Почему main не ждёт goroutine

package main
import "fmt"
func main() {
go fmt.Println("hello")
}

Почему time.Sleep — плохой способ ждать goroutine

func main() {
go worker()
time.Sleep(time.Second)
}

sync.WaitGroup: как дождаться завершения goroutine

package main
import (
"fmt"
"sync"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Println("worker", id, "done")
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 3; i++ {
wg.Add(1)
go worker(i, &wg)
}
wg.Wait()
fmt.Println("all workers done")
}

Частая ошибка с WaitGroup

for i := 0; i < 3; i++ {
go func() {
wg.Add(1)
defer wg.Done()
work()
}()
}
wg.Wait()

Что делать, если goroutine должна вернуть результат

go calculate()

package main
import "fmt"
func main() {
resultCh := make(chan int)
go func() {
resultCh <- 42
}()
result := <-resultCh
fmt.Println(result)
}

Что такое канал простыми словами

goroutine → channel → другая goroutine

ch <- 42

value := <-ch

msg := <-ch

Ошибки внутри goroutine

go func() {
if err := doWork(); err != nil {
fmt.Println(err)
}
}()

type Result struct {
Value int
Err error
}
func main() {
resultCh := make(chan Result)
go func() {
value, err := doWork()
resultCh <- Result{Value: value, Err: err}
}()
result := <-resultCh
if result.Err != nil {
fmt.Println("error:", result.Err)
return
}
fmt.Println(result.Value)
}

Panic внутри goroutine

file, err := os.Open("data.txt")
if err != nil {
fmt.Println(err)
}

panic("something went wrong")

package main
func main() {
go func() {
panic("boom")
}()
select {}
}

go func() {
defer func() {
if r := recover(); r != nil {
fmt.Println("recovered:", r)
}
}()
riskyWork()
}()

Race condition

counter++

go test -race ./...

goroutine могут одновременно работать с одной памятью
и это опасно без синхронизации

Mutex, RWMutex и atomic: базовое понимание

var mu sync.Mutex
mu.Lock()
counter++
mu.Unlock()

var counter atomic.Int64
counter.Add(1)

Context и отмена горутины

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

func worker(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
default:
doWork()
}
}
}

ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
select {
case result := <-resultCh:
fmt.Println(result)
case <-ctx.Done():
fmt.Println("timeout:", ctx.Err())
}

Утечка горутин: goroutine leak

func leak() {
ch := make(chan int)
go func() {
value := <-ch
fmt.Println(value)
}()
}

fmt.Println(runtime.NumGoroutine())

Как ограничивать количество goroutine

for _, task := range tasks {
go process(task)
}

sem := make(chan struct{}, 10)
for _, task := range tasks {
sem <- struct{}{}
go func(task Task) {
defer func() { <-sem }()
process(task)
}(task)
}

Worker Pool

jobs → workers → results

Fan-in / Fan-out в Go

fan-out: одна очередь → много goroutine
fan-in: много goroutine → один результат

Что спрашивают на собеседованиях по goroutine

Как изучать goroutine правильно

Где goroutine нужны в реальной работе

FAQ по горутинам