---

package main

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

func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		for i := 1; i <= 5; i++ {
			fmt.Println(i)
			time.Sleep(time.Second)
		}
	}()
	wg.Wait()
}
package main

import (
	"fmt"
	"sync"
)

func worker(jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for n := range jobs {
		results <- n * n
	}
}

func main() {
	jobs := make(chan int, 10)
	results := make(chan int, 10)
	var wg sync.WaitGroup

	for w := 0; w < 3; w++ {
		wg.Add(1)
		go worker(jobs, results, &wg)
	}
	for i := 1; i <= 10; i++ {
		jobs <- i
	}
	close(jobs) // сообщаем воркерам, что задач больше не будет

	wg.Wait()
	close(results)

	for r := range results {
		fmt.Println(r)
	}
}
package main

import (
	"fmt"
	"time"
)

func main() {
	tick := time.Tick(200 * time.Millisecond)
	for i := 1; i <= 15; i++ {
		<-tick // ждём следующий "тик", это и есть ограничение 5 в секунду
		fmt.Println("запрос", i, time.Now().Format("15:04:05.000"))
	}
}
package main

import (
	"fmt"
	"net/http"
	"sync"
)

func worker(urls <-chan string, wg *sync.WaitGroup) {
	defer wg.Done()
	for url := range urls {
		resp, err := http.Get(url)
		if err != nil {
			fmt.Println(url, "ошибка:", err)
			continue
		}
		fmt.Println(url, resp.Status)
		resp.Body.Close()
	}
}

func main() {
	list := []string{
		"https://go.dev", "https://github.com", "https://example.com",
		"https://yandex.ru", "https://google.com",
	}
	urls := make(chan string)
	var wg sync.WaitGroup

	for i := 0; i < 3; i++ {
		wg.Add(1)
		go worker(urls, &wg)
	}
	for _, u := range list {
		urls <- u
	}
	close(urls)
	wg.Wait()
}
package main

import (
	"crypto/md5"
	"fmt"
	"io"
	"os"
	"sync"
)

func hashFile(path string) (string, error) {
	f, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer f.Close()

	h := md5.New()
	if _, err := io.Copy(h, f); err != nil {
		return "", err
	}
	return fmt.Sprintf("%x", h.Sum(nil)), nil
}

func worker(paths <-chan string, wg *sync.WaitGroup) {
	defer wg.Done()
	for p := range paths {
		sum, err := hashFile(p)
		if err != nil {
			fmt.Println(p, "ошибка:", err)
			continue
		}
		fmt.Println(p, sum)
	}
}

func main() {
	paths := make(chan string)
	var wg sync.WaitGroup

	for i := 0; i < 3; i++ { // не больше 3 открытых файлов одновременно
		wg.Add(1)
		go worker(paths, &wg)
	}
	for _, p := range os.Args[1:] {
		paths <- p
	}
	close(paths)
	wg.Wait()
}
package main

import (
	"fmt"
	"math/rand"
	"time"
)

func search(name string, out chan<- string) {
	delay := time.Duration(rand.Intn(1000)) * time.Millisecond
	time.Sleep(delay)
	out <- fmt.Sprintf("результат из %s (за %v)", name, delay)
}

func main() {
	sources := []string{"база 1", "база 2", "API"}
	out := make(chan string, len(sources)) // с буфером, чтобы медленные горутины не зависли

	for _, s := range sources {
		go search(s, out)
	}

	select {
	case res := <-out:
		fmt.Println("первый:", res)
	case <-time.After(2 * time.Second):
		fmt.Println("таймаут")
	}
}
package main

import (
	"fmt"
	"sync"
)

type Manager struct {
	inc chan int
	get chan chan int
}

func NewManager() *Manager {
	m := &Manager{inc: make(chan int), get: make(chan chan int)}
	go func() {
		counter := 0 // состояние живёт только внутри этой горутины
		for {
			select {
			case d := <-m.inc:
				counter += d
			case reply := <-m.get:
				reply <- counter
			}
		}
	}()
	return m
}

func main() {
	m := NewManager()
	var wg sync.WaitGroup

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			m.inc <- 1
		}()
	}
	wg.Wait()

	reply := make(chan int)
	m.get <- reply
	fmt.Println("счётчик:", <-reply) // 100
}
package main

import (
	"fmt"
	"sync"
)

func server(id int, requests <-chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	for r := range requests {
		fmt.Printf("сервер %d обработал запрос %d\n", id, r)
	}
}

func main() {
	const n = 3
	servers := make([]chan int, n)
	var wg sync.WaitGroup

	for i := 0; i < n; i++ {
		servers[i] = make(chan int)
		wg.Add(1)
		go server(i+1, servers[i], &wg)
	}

	for req := 1; req <= 10; req++ {
		servers[(req-1)%n] <- req // по кругу: 1, 2, 3, 1, 2, 3...
	}
	for _, ch := range servers {
		close(ch)
	}
	wg.Wait()
}