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

Идея была в том, чтобы эффективно управлять большим количеством асинхронных задач, не создавая слишком много горутин, что могло бы привести к избыточному потреблению памяти и снижению производительности.

Пример упрощённой реализации пула:

package main

import (
    "fmt"
    "sync"
)

type Task func()

type Pool struct {
    tasks    chan Task
    wg       sync.WaitGroup
}

func NewPool(workerCount int) *Pool {
    p := &Pool{
        tasks: make(chan Task),
    }
    p.wg.Add(workerCount)
    for i := 0; i < workerCount; i++ {
        go func() {
            defer p.wg.Done()
            for task := range p.tasks {
                task()
            }
        }()
    }
    return p
}

func (p *Pool) Submit(task Task) {
    p.tasks <- task
}

func (p *Pool) Shutdown() {
    close(p.tasks)
    p.wg.Wait()
}

func main() {
    pool := NewPool(5)

    for i := 0; i < 10; i++ {
        n := i
        pool.Submit(func() {
            fmt.Printf("Task %d is running\n", n)
        })
    }

    pool.Shutdown()
}

Такой подход позволяет контролировать параллелизм и избегать создания слишком большого количества горутин, что полезно при работе с ограниченными ресурсами или внешними API.

Можешь привести пример конкретной нетривиальной реализации, которую ты делал лично?