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 HttpClientstream()с обработкой исключений. 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;
}
}
Как это работает: первая горутина, вернувшая ошибку, отменяет общий 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 - стандартный способ.