errgroup и graceful shutdown

errgroup и graceful shutdown

WaitGroup не умеет возвращать ошибки и отменять другие горутины при ошибке. Для этого есть errgroup поверх context.

errgroup: WaitGroup с ошибками

import "golang.org/x/sync/errgroup"

func fetchAll(ctx context.Context, urls []string) ([]string, error) {
    g, ctx := errgroup.WithContext(ctx)
    results := make([]string, len(urls))

    for i, url := range urls {
        // копия i, url := i, url не нужна: с go 1.22 в go.mod
        // каждая итерация получает свои переменные
        g.Go(func() error {
            body, err := fetchURL(ctx, url)
            if err != nil {
                return err // отменит ctx для всех
            }
            results[i] = body
            return nil
        })
    }

    if err := g.Wait(); err != nil {
        return nil, err
    }
    return results, nil
}
<?php

declare(strict_types=1);

namespace App\Concurrency;

use Psr\Http\Message\ResponseInterface;
use React\Http\Browser;
use React\Promise\PromiseInterface;

use function React\Promise\all;

final readonly class ParallelFetcher
{
    // Browser из react/http работает на event loop, поэтому запросы идут
    // параллельно. Symfony HttpClient внутри async() так не умеет: его
    // getContent() блокирует поток, и запросы выполнятся по очереди.
    public function __construct(private Browser $browser) {}

    /**
     * @param list<string> $urls
     * @return PromiseInterface<list<string>>
     */
    public function fetchAll(array $urls): PromiseInterface
    {
        $promises = [];
        foreach ($urls as $url) {
            $promises[] = $this->browser->get($url)->then(
                static fn (ResponseInterface $response): string => (string) $response->getBody(),
            );
        }

        // all() резолвится при успехе всех или режектится при первой ошибке
        return all($promises);
    }
}

В PHP ближайший аналог - ReactPHP Promise\all (ждёт все, fails-fast на первой ошибке) или Symfony HttpClient stream() с обработкой исключений. Cancellation в ReactPHP - метод cancel() у PromiseInterface (в promise v3). Symfony Messenger предлагает BatchHandlerInterface для пакетной обработки, но без авто-отмены - там скорее retry-логика, чем fail-fast.

Sync-вариант на Symfony HttpClient (без ReactPHP):

<?php

declare(strict_types=1);

namespace App\Concurrency;

use Symfony\Contracts\HttpClient\HttpClientInterface;
use Throwable;

final readonly class SyncParallelFetcher
{
    public function __construct(private HttpClientInterface $client) {}

    /**
     * @param list<string> $urls
     * @return list<string>
     */
    public function fetchAll(array $urls): array
    {
        $responses = [];
        foreach ($urls as $i => $url) {
            $responses[$i] = $this->client->request('GET', $url);
        }

        $results = [];
        try {
            foreach ($this->client->stream($responses) as $response => $chunk) {
                if ($chunk->isLast()) {
                    $idx = \array_search($response, $responses, true);
                    $results[$idx] = $response->getContent();
                }
            }
        } catch (Throwable $e) {
            // fail-fast: отменяем остальные
            foreach ($responses as $r) {
                $r->cancel();
            }
            throw $e;
        }

        return $results;
    }
}

errgroup: первая ошибка отменяет общий ctx, оставшиеся горутины завершаются по ctx.Done(), Wait возвращает первую ошибку

Как это работает: первая горутина, вернувшая ошибку, отменяет общий ctx. Остальные горутины никто не убивает - они должны сами заметить ctx.Done() и выйти. g.Wait() дожидается их всех и возвращает первую ошибку; остальные ошибки теряются. Если нужны все, собирай их сам и склеивай через errors.Join.

errgroup с лимитом конкурентности

g, ctx := errgroup.WithContext(ctx)
g.SetLimit(5) // максимум 5 горутин одновременно

for _, task := range tasks {
    g.Go(func() error {
        return processTask(ctx, task)
    })
}

if err := g.Wait(); err != nil {
    log.Fatal(err)
}

Graceful shutdown HTTP-сервера

func main() {
    srv := &http.Server{Addr: ":8080"}

    // Запускаем сервер в горутине
    go func() {
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatalf("HTTP server error: %v", err)
        }
    }()

    // Ждём сигнала завершения
    ctx, stop := signal.NotifyContext(context.Background(),
        syscall.SIGINT, syscall.SIGTERM,
    )
    defer stop()

    <-ctx.Done()
    log.Println("Shutting down...")

    // Даём 10 секунд на завершение текущих запросов
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    if err := srv.Shutdown(shutdownCtx); err != nil {
        log.Fatalf("Shutdown error: %v", err)
    }
    log.Println("Server stopped")
}
<?php

declare(strict_types=1);

namespace App\Concurrency;

use Psr\Http\Message\ServerRequestInterface;
use React\EventLoop\Loop;
use React\Http\HttpServer;
use React\Http\Message\Response;
use React\Socket\SocketServer;
use SIGINT;
use SIGTERM;

final class GracefulHttpServer
{
    public function start(string $listen, int $shutdownTimeoutSec): void
    {
        $http = new HttpServer(
            static fn (ServerRequestInterface $request): Response => new Response(200, [], 'ok'),
        );

        $socket = new SocketServer($listen);
        $http->listen($socket);

        $shutdown = function () use ($socket, $shutdownTimeoutSec): void {
            $socket->close(); // перестаём принимать соединения
            Loop::addTimer(
                $shutdownTimeoutSec,
                static fn () => Loop::stop(),
            );
        };

        Loop::addSignal(SIGTERM, $shutdown);
        Loop::addSignal(SIGINT, $shutdown);
    }
}

В классическом PHP-FPM graceful shutdown HTTP-сервера - это задача fpm и nginx, а не приложения: php-fpm ловит SIGQUIT, дожидается завершения запущенных запросов. Приложение участвует только если живёт долго - воркер Symfony Messenger или ReactPHP Http\Server. У Messenger флаги --time-limit и --memory-limit, у ReactPHP - Loop::addSignal.

Паттерн: запуск нескольких сервисов

func run(ctx context.Context) error {
    g, ctx := errgroup.WithContext(ctx)

    // HTTP сервер
    g.Go(func() error {
        return runHTTPServer(ctx, ":8080")
    })

    // gRPC сервер
    g.Go(func() error {
        return runGRPCServer(ctx, ":9090")
    })

    // Worker для очередей
    g.Go(func() error {
        return runConsumer(ctx)
    })

    return g.Wait()
}

Чтобы паттерн работал, каждый компонент должен сам останавливаться по ctx. Например, HTTP-сервер:

func runHTTPServer(ctx context.Context, addr string) error {
    srv := &http.Server{Addr: addr}

    go func() {
        <-ctx.Done() // сигнал ОС или ошибка соседнего компонента
        shCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
        defer cancel()
        srv.Shutdown(shCtx) // дождаться текущих запросов, но не дольше 10 секунд
    }()

    if err := srv.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
        return err // порт занят и т.п. - errgroup отменит ctx для остальных
    }
    return nil
}

func main() {
    // ctx отменится по Ctrl+C или SIGTERM от Kubernetes/systemd
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
    defer stop()

    if err := run(ctx); err != nil {
        log.Fatal(err)
    }
}
<?php

declare(strict_types=1);

use Psr\Http\Message\ServerRequestInterface;
use React\EventLoop\Loop;
use React\Http\HttpServer;
use React\Http\Message\Response;
use React\Socket\SocketServer;

// PHP-аналог: компонент сам останавливается по сигналу.
$http = new HttpServer(static fn (ServerRequestInterface $request) => Response::plaintext("ok\n"));
$socket = new SocketServer('0.0.0.0:8080');
$http->listen($socket);

$shutdown = static function () use ($socket, &$shutdown): void {
    $socket->close(); // перестать принимать новые соединения
    Loop::removeSignal(SIGTERM, $shutdown);
    Loop::removeSignal(SIGINT, $shutdown);
    // loop завершится сам, когда допишутся текущие ответы
};
Loop::addSignal(SIGTERM, $shutdown);
Loop::addSignal(SIGINT, $shutdown);

Важная деталь: ctx группы отменяется только когда компонент вернул ошибку (или отменён родительский ctx). Если компонент вернул nil, остальные продолжат работать, а g.Wait() будет ждать их дальше. Поэтому долгоживущий компонент не должен молча возвращать nil, пока сервис не останавливается.

ℹ️ Правило

Любая горутина, которая может упасть - должна уметь сообщить об этом наверх. errgroup + context - стандартный способ.

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