Go для бэкенда: goroutines и channels

1package main
2
3import (
4    "fmt"
5    "time"
6)
7
8func worker(id int) {
9    fmt.Printf("Worker %d starting\n", id)
10    time.Sleep(time.Second)
11    fmt.Printf("Worker %d done\n", id)
12}
13
14func main() {
15    // Запуск goroutine
16    go worker(1)
17    go worker(2)
18
19    // Ожидание завершения
20    time.Sleep(2 * time.Second)
21    fmt.Println("Main done")
22}

1package main
2
3import (
4    "fmt"
5    "sync"
6)
7
8func main() {
9    var wg sync.WaitGroup
10
11    for i := 1; i <= 5; i++ {
12        wg.Add(1)
13        go func(id int) {
14            defer wg.Done()
15            fmt.Printf("Worker %d\n", id)
16        }(i)
17    }
18
19    wg.Wait()
20    fmt.Println("All workers done")
21}

1package main
2
3import "fmt"
4
5func main() {
6    // Создание канала
7    ch := make(chan string)
8
9    // Отправка данных (в goroutine)
10    go func() {
11        ch <- "Hello from goroutine"
12    }()
13
14    // Получение данных
15    msg := <-ch
16    fmt.Println(msg)
17}

1func main() {
2    // Буфер на 3 элемента
3    ch := make(chan int, 3)
4
5    ch <- 1
6    ch <- 2
7    ch <- 3
8
9    fmt.Println(<-ch) // 1
10    fmt.Println(<-ch) // 2
11    fmt.Println(<-ch) // 3
12}

1func producer(ch chan<- int) {
2    for i := 0; i < 10; i++ {
3        ch <- i
4    }
5    close(ch) // Закрытие канала
6}
7
8func consumer(ch <-chan int) {
9    for value := range ch { // Автоматическая проверка закрытия
10        fmt.Println(value)
11    }
12}
13
14func main() {
15    ch := make(chan int)
16    go producer(ch)
17    consumer(ch)
18}

1func main() {
2    ch1 := make(chan string)
3    ch2 := make(chan string)
4
5    go func() {
6        time.Sleep(1 * time.Second)
7        ch1 <- "one"
8    }()
9
10    go func() {
11        time.Sleep(2 * time.Second)
12        ch2 <- "two"
13    }()
14
15    for i := 0; i < 2; i++ {
16        select {
17        case msg := <-ch1:
18            fmt.Println("Received from ch1:", msg)
19        case msg := <-ch2:
20            fmt.Println("Received from ch2:", msg)
21        }
22    }
23}

1func main() {
2    ch := make(chan string)
3
4    go func() {
5        time.Sleep(3 * time.Second)
6        ch <- "result"
7    }()
8
9    select {
10    case result := <-ch:
11        fmt.Println("Got result:", result)
12    case <-time.After(2 * time.Second):
13        fmt.Println("Timeout!")
14    }
15}

1func fanOut(input <-chan int, workers int) []<-chan int {
2    channels := make([]<-chan int, workers)
3    for i := 0; i < workers; i++ {
4        channels[i] = process(input)
5    }
6    return channels
7}
8
9func fanIn(channels ...<-chan int) <-chan int {
10    var wg sync.WaitGroup
11    merged := make(chan int)
12
13    for _, ch := range channels {
14        wg.Add(1)
15        go func(c <-chan int) {
16            defer wg.Done()
17            for value := range c {
18                merged <- value
19            }
20        }(ch)
21    }
22
23    go func() {
24        wg.Wait()
25        close(merged)
26    }()
27
28    return merged
29}

1func generate(nums ...int) <-chan int {
2    out := make(chan int)
3    go func() {
4        for _, n := range nums {
5            out <- n
6        }
7        close(out)
8    }()
9    return out
10}
11
12func square(in <-chan int) <-chan int {
13    out := make(chan int)
14    go func() {
15        for n := range in {
16            out <- n * n
17        }
18        close(out)
19    }()
20    return out
21}
22
23func main() {
24    // Pipeline: generate -> square
25    for value := range square(generate(2, 3, 4)) {
26        fmt.Println(value) // 4, 9, 16
27    }
28}

1func worker(ctx context.Context) {
2    for {
3        select {
4        case <-ctx.Done():
5            fmt.Println("Worker cancelled:", ctx.Err())
6            return
7        default:
8            fmt.Println("Working...")
9            time.Sleep(100 * time.Millisecond)
10        }
11    }
12}
13
14func main() {
15    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
16    defer cancel()
17
18    go worker(ctx)
19    time.Sleep(time.Second)
20}

1type Counter struct {
2    mu    sync.Mutex
3    value int
4}
5
6func (c *Counter) Increment() {
7    c.mu.Lock()
8    defer c.mu.Unlock()
9    c.value++
10}
11
12func (c *Counter) Value() int {
13    c.mu.Lock()
14    defer c.mu.Unlock()
15    return c.value
16}

1func BenchmarkWorker(b *testing.B) {
2    for i := 0; i < b.N; i++ {
3        // Тестируемая функция
4    }
5}

1import "runtime/pprof"
2
3func main() {
4    f, _ := os.Create("cpu.prof")
5    pprof.StartCPUProfile(f)
6    defer pprof.StopCPUProfile()
7    // Код для профилирования
8}