// До Go 1.14 этот цикл мог заблокировать P, не давая другим G исполняться
for {
    x++ // нет точек переключения - runtime не может прервать
}

<?php
declare(strict_types=1);

// Аналог в ReactPHP: длинный CPU-цикл блокирует event loop
React\EventLoop\Loop::addPeriodicTimer(0.1, function (): void {
    echo "tick\n"; // НЕ выполнится, пока ниже идёт цикл
});

$x = 0;
while (true) {
    $x++; // ни один callback из loop не получит управление
}

// Идиоматичное решение - max_execution_time + вынос тяжёлого в Symfony Messenger
// или явная отдача управления через Loop::futureTick():
function chunkedWork(int $total, int $chunk = 1000): void
{
    $done = 0;
    $tick = function () use (&$done, &$tick, $total, $chunk): void {
        for ($i = 0; $i < $chunk && $done < $total; $i++, $done++) {
            // работа
        }
        if ($done < $total) {
            React\EventLoop\Loop::futureTick($tick); // вернуть управление loop'у
        }
    };
    $tick();
}

В PHP нет преемптивного планировщика на уровне языка. CPU-bound цикл блокирует весь request в FPM до завершения. Если запустить такой код в ReactPHP event loop, он заблокирует все остальные I/O-callback'и - кооперативная многозадачность не «вытесняет» сама.

func main() {
    // Обычный поток ОС: ~1-8 MB стека
    // Горутина: ~2-8 KB начального стека
    fmt.Printf("Горутин до: %d\n", runtime.NumGoroutine())

    var wg sync.WaitGroup
    for i := 0; i < 100_000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            time.Sleep(time.Second)
        }()
    }

    fmt.Printf("Горутин: %d\n", runtime.NumGoroutine())
    wg.Wait()
}

<?php

declare(strict_types=1);

namespace App\Concurrency;

use Symfony\Component\Messenger\Attribute\AsMessageHandler;
use Symfony\Component\Messenger\MessageBusInterface;

final readonly class SleepTask
{
    public function __construct(public int $id) {}
}

#[AsMessageHandler]
final readonly class SleepTaskHandler
{
    public function __invoke(SleepTask $task): void
    {
        sleep(1); // задача в отдельном воркер-процессе
    }
}

final readonly class TaskDispatcher
{
    public function __construct(private MessageBusInterface $bus) {}

    public function dispatchMany(int $count): void
    {
        for ($i = 0; $i < $count; $i++) {
            // НЕ запускаем процесс - кладём в очередь (Redis/AMQP)
            $this->bus->dispatch(new SleepTask($i));
        }
    }
}

В PHP нет native goroutines и собственного планировщика типа GMP. PHP-FPM запускает request → выполняет синхронно → завершается. Чтобы «запустить 100 000 задач параллельно», нужно либо вынести их в очередь (Symfony Messenger async transport + N воркеров), либо использовать event loop (ReactPHP), либо отдельную coroutine-runtime (Swoole go(function () {...})). Промышленный референс - Symfony Messenger: dispatch в очередь, воркеры consume.

// УТЕЧКА: никто не пишет в канал и не закрывает его
func leak() <-chan int {
    ch := make(chan int)
    go func() {
        val := <-ch // заблокирована навсегда
        fmt.Println(val)
    }()
    return ch
}

<?php
declare(strict_types=1);

// PHP-эквивалент в ReactPHP: Promise без resolve - callback'и накапливаются в loop
use React\Promise\Deferred;

final class LeakyConsumer
{
    public function leak(): \React\Promise\PromiseInterface
    {
        $deferred = new Deferred();
        // никто не вызовет $deferred->resolve() - then-handler живёт в памяти loop'а
        return $deferred->promise()->then(static function (int $val): void {
            echo $val;
        });
    }
}

// Защита: всегда выставлять timeout
use React\Promise\Timer;

$promise = Timer\timeout($deferred->promise(), 5.0, React\EventLoop\Loop::get());
// reject через 5 секунд, если никто не resolve'нул

// УТЕЧКА: producer пишет, consumer ушёл по таймауту
func produce(ctx context.Context) <-chan int {
    out := make(chan int) // unbuffered
    go func() {
        for i := 0; i < 1000; i++ {
            out <- i // зависнет на втором итерации, если consumer ушёл
        }
    }()
    return out
}

<?php
declare(strict_types=1);

// PHP-эквивалент в Symfony Messenger: producer кладёт в очередь, никто не consume.
// Очередь растёт - аналог «канал переполнен», но без потери сообщений.
final class LeakyProducer
{
    public function __construct(
        private readonly \Symfony\Component\Messenger\MessageBusInterface $bus,
    ) {}

    public function produceMany(int $count): void
    {
        for ($i = 0; $i < $count; $i++) {
            $this->bus->dispatch(new Job($i));
            // Если consumer-воркер не запущен, очередь Redis/AMQP растёт до OOM брокера
        }
    }
}

// Защита: queue с TTL для сообщений (Redis: stream MAXLEN, AMQP: x-message-ttl)
// + мониторинг lag через messenger:stats

func leakyTicker() {
    ticker := time.NewTicker(time.Second)
    go func() {
        for range ticker.C {
            // работа
        }
    }()
    // ticker.Stop() никогда не вызван - горутина и канал живут вечно
}

<?php
declare(strict_types=1);

// PHP-эквивалент в ReactPHP: периодический timer без cancelTimer()
use React\EventLoop\Loop;

final class LeakyTicker
{
    public function start(): void
    {
        $timer = Loop::addPeriodicTimer(1.0, static function (): void {
            // работа каждую секунду
        });
        // Если не вызвать Loop::cancelTimer($timer) - таймер живёт до конца процесса
    }

    public function safeStart(int $maxTicks): void
    {
        $count = 0;
        $timer = null;
        $timer = Loop::addPeriodicTimer(1.0, static function () use (&$count, &$timer, $maxTicks): void {
            if (++$count >= $maxTicks && $timer !== null) {
                Loop::cancelTimer($timer); // явный путь выхода
            }
        });
    }
}

// УТЕЧКА: cancel не вызван → внутренние горутины context не освобождаются
func bad() {
    ctx, _ := context.WithCancel(context.Background())
    doWork(ctx)
    // забыли defer cancel()
}

Линтер govet (с -printf.funcs) и staticcheck (правило SA1029) ловят такие случаи.

<?php
declare(strict_types=1);

// В PHP нет context.Context. Эквивалентом «cancel» при долгой операции служит:
// - max_execution_time (set_time_limit) для FPM
// - --time-limit для Messenger воркера
// - Doctrine\DBAL\Connection statement_timeout для SQL

use Symfony\Component\Stopwatch\Stopwatch;

final class TimedWorker
{
    public function __construct(private readonly Stopwatch $stopwatch) {}

    public function process(iterable $items, float $deadlineSec): void
    {
        $this->stopwatch->start('process');
        foreach ($items as $item) {
            if ($this->stopwatch->getEvent('process')->getDuration() / 1000 >= $deadlineSec) {
                throw new \RuntimeException('deadline exceeded');
            }
            $this->handle($item);
        }
    }

    private function handle(mixed $item): void {}
}

func worker(done <-chan struct{}, jobs <-chan Job) {
    for {
        select {
        case <-done:
            return // явный путь выхода
        case j := <-jobs:
            process(j)
        }
    }
}

<?php
declare(strict_types=1);

// PHP-эквивалент через Symfony Messenger: воркер сам проверяет shouldStop()
use Symfony\Component\Messenger\Event\WorkerRunningEvent;
use Symfony\Component\Messenger\EventListener\StopWorkerOnSignalsListener;

// Symfony автоматически слушает SIGTERM/SIGINT и вызывает $worker->stop().
// В свежем worker loop'е перед обработкой следующего message проверяется shouldStop:
// аналог `<-done` в Go.

// Можно явно остановить:
final class GracefulStopper
{
    public function __construct(
        private readonly \Symfony\Component\EventDispatcher\EventDispatcherInterface $events,
    ) {}

    public function stopAfter(int $messages): void
    {
        $count = 0;
        $this->events->addListener(WorkerRunningEvent::class, static function (WorkerRunningEvent $e) use (&$count, $messages): void {
            if (++$count >= $messages) {
                $e->getWorker()->stop();
            }
        });
    }
}

func worker(ctx context.Context, jobs <-chan Job) {
    for {
        select {
        case <-ctx.Done():
            return
        case j := <-jobs:
            process(ctx, j) // context дальше по цепочке
        }
    }
}

<?php
declare(strict_types=1);

// PHP-эквивалент context.Context - request-scoped DI-сервис, передающий correlation_id,
// deadline и cancellation signal через всю цепочку вызовов.
final class RequestContext
{
    private bool $cancelled = false;
    private readonly float $deadlineTs;

    public function __construct(
        public readonly string $correlationId,
        float $timeoutSec,
    ) {
        $this->deadlineTs = microtime(true) + $timeoutSec;
    }

    public function cancel(): void { $this->cancelled = true; }

    public function isDone(): bool
    {
        return $this->cancelled || microtime(true) >= $this->deadlineTs;
    }

    public function ensureNotDone(): void
    {
        if ($this->isDone()) {
            throw new \RuntimeException('context cancelled or deadline exceeded');
        }
    }
}

final class WorkerService
{
    public function process(RequestContext $ctx, iterable $jobs): void
    {
        foreach ($jobs as $job) {
            $ctx->ensureNotDone();
            $this->handle($ctx, $job); // ctx идёт дальше по цепочке
        }
    }

    private function handle(RequestContext $ctx, mixed $job): void {}
}

// В тестах: проверяем количество горутин
func TestNoLeaks(t *testing.T) {
    before := runtime.NumGoroutine()

    // ... тестируемый код ...

    time.Sleep(100 * time.Millisecond)
    after := runtime.NumGoroutine()

    if after > before+1 {
        t.Errorf("goroutine leak: before=%d, after=%d", before, after)
    }
}

// Через pprof
import _ "net/http/pprof"

go func() {
    log.Println(http.ListenAndServe(":6060", nil))
}()
// go tool pprof http://localhost:6060/debug/pprof/goroutine

<?php
declare(strict_types=1);

// PHP не имеет «горутин», но есть аналог для long-running воркеров:
// проверка memory_get_usage() и количества подписок event-loop'а.
use PHPUnit\Framework\TestCase;
use React\EventLoop\Loop;

final class WorkerLeakTest extends TestCase
{
    public function testNoMemoryLeak(): void
    {
        $before = memory_get_usage();

        // ... тестируемый код через event loop ...
        $service = new EventLoopService();
        $service->run(iterations: 1000);

        gc_collect_cycles();
        $after = memory_get_usage();

        // ReactPHP loop должен освободить все timer/promise callback'и
        self::assertLessThan($before * 1.05, $after, 'memory grew >5% - possible leak');
    }
}

// Для production-мониторинга: prometheus-метрика messenger_queue_size + memory_get_usage
// плюс php-prometheus-exporter для счётчиков queue lag.

func fanOut(in <-chan int, workers int) []<-chan int {
    outs := make([]<-chan int, workers)
    for i := 0; i < workers; i++ {
        out := make(chan int)
        outs[i] = out
        go func() {
            defer close(out)
            for v := range in {
                out <- heavyCompute(v)
            }
        }()
    }
    return outs
}

<?php
declare(strict_types=1);

// PHP-эквивалент через Symfony Messenger: один transport - один очередь,
// N воркеров (numprocs=N в supervisord) - fan-out параллелизация.
use Symfony\Component\Messenger\MessageBusInterface;

final readonly class HeavyComputeMessage
{
    public function __construct(public int $value) {}
}

final class FanOutDispatcher
{
    public function __construct(private readonly MessageBusInterface $bus) {}

    public function dispatchAll(iterable $values): void
    {
        // dispatch в общий transport - воркеры разберут параллельно
        foreach ($values as $v) {
            $this->bus->dispatch(new HeavyComputeMessage($v));
        }
    }
}

// Результаты собираются через отдельную result-очередь или через DB - fan-in.
// Запуск: supervisord с 4 workers consuming тот же transport.

nums := generate(ctx)        // stage 1
squared := square(ctx, nums) // stage 2
for v := range squared {     // stage 3 (consumer)
    fmt.Println(v)
}

<?php
declare(strict_types=1);

// PHP-эквивалент в Symfony Messenger - chain of message handlers через несколько transport'ов:
// transport "generated" → handler → dispatch в "squared" → handler → dispatch в "consumed"
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
use Symfony\Component\Messenger\MessageBusInterface;

final readonly class GeneratedNumber { public function __construct(public int $n) {} }
final readonly class SquaredNumber   { public function __construct(public int $n) {} }

#[AsMessageHandler]
final readonly class SquareStage
{
    public function __construct(private MessageBusInterface $bus) {}

    public function __invoke(GeneratedNumber $msg): void
    {
        $this->bus->dispatch(new SquaredNumber($msg->n * $msg->n));
    }
}

#[AsMessageHandler]
final readonly class ConsumeStage
{
    public function __invoke(SquaredNumber $msg): void
    {
        echo $msg->n . "\n";
    }
}
// Backpressure - max-size + DLQ для каждого transport'а в messenger.yaml

runtime.NumGoroutine()     // количество горутин
runtime.NumCPU()           // количество CPU ядер
runtime.GOMAXPROCS(0)      // текущее GOMAXPROCS (0 = чтение)
runtime.Gosched()          // уступить время другим горутинам (редко нужен с 1.14+)
runtime.Goexit()           // завершить текущую горутину (defer'ы выполнятся)

<?php
declare(strict_types=1);

// PHP-аналоги для интроспекции воркеров и процессов:
$workerCount = (int) shell_exec("pgrep -c -f 'messenger:consume async' || echo 0");
$cpuCount = (int) shell_exec('nproc'); // или sysctl -n hw.ncpu на macOS

// Память процесса:
$mem = memory_get_usage(real_usage: true);
$peak = memory_get_peak_usage(real_usage: true);

// «Уступить управление» в ReactPHP loop:
React\EventLoop\Loop::futureTick(static fn () => null); // отдать тик loop'у

// Корректное завершение Messenger воркера:
final class WorkerStopper
{
    public function stopGracefully(\Symfony\Component\Messenger\Worker $worker): void
    {
        $worker->stop(); // обработает текущее message и выйдет
    }
}

// БАГ до Go 1.22: все горутины напечатают одно и то же значение i
for i := 0; i < 5; i++ {
    go func() {
        fmt.Println(i) // i делится между всеми горутинами
    }()
}

// FIX: передать i параметром
for i := 0; i < 5; i++ {
    go func(i int) {
        fmt.Println(i)
    }(i)
}

<?php
declare(strict_types=1);

// В PHP замыкание захватывает переменные ПО ЗНАЧЕНИЮ (по умолчанию), а не по ссылке.
// Аналогичной ловушки нет - каждый callback видит свой $i:
$callbacks = [];
for ($i = 0; $i < 5; $i++) {
    $callbacks[] = static function () use ($i): void {
        echo $i . "\n"; // 0, 1, 2, 3, 4
    };
}
foreach ($callbacks as $cb) $cb();

// А вот если использовать `use (&$i)` - ловушка возвращается:
$callbacks = [];
for ($i = 0; $i < 5; $i++) {
    $callbacks[] = static function () use (&$i): void {
        echo $i . "\n"; // 5, 5, 5, 5, 5 - захват по ссылке
    };
}

// БАГ: wg.Wait может пройти до того, как Add успеет выполниться
for _, item := range items {
    go func() {
        wg.Add(1) // СЛИШКОМ ПОЗДНО
        defer wg.Done()
        process(item)
    }()
}
wg.Wait()

<?php
declare(strict_types=1);

// PHP-аналог в ReactPHP: Promise\all() ждёт завершения всех заранее переданных promises.
// Если добавлять promise В цикле resolve - аналогичная гонка: all() уже резолвится.
use function React\Promise\all;
use React\Promise\PromiseInterface;

final class BatchProcessor
{
    /** @param list<PromiseInterface> $tasks */
    public function processAll(array $tasks): PromiseInterface
    {
        // Правильно: список promises собран ДО all()
        return all($tasks);
    }
}

// Анти-паттерн через симфоновый MessageBatch - assert(count >= N) до dispatch:
final class SafeBatch
{
    public function dispatch(array $messages): void
    {
        assert(count($messages) > 0, 'batch must contain at least 1 message');
        // Только теперь dispatch - аналог wg.Add() до go-spawn
    }
}

// БАГ: конкурентная запись в map → panic «concurrent map writes»
m := map[string]int{}
for _, k := range keys {
    go func(k string) {
        m[k]++ // race
    }(k)
}

<?php
declare(strict_types=1);

// В PHP-FPM нет shared state между запросами - race в этом смысле невозможна.
// Но между Messenger воркерами или ReactPHP-промисами в одном loop'е race на
// shared resource (БД, Redis, файл) - реальна. Решение - distributed lock или
// atomic-операции на уровне хранилища.
use Symfony\Component\Lock\LockFactory;

final class SafeCounter
{
    public function __construct(
        private readonly \Redis $redis,
        private readonly LockFactory $lockFactory,
    ) {}

    // Без атомарности - race condition между воркерами:
    public function unsafeIncrement(string $key): void
    {
        $current = (int) $this->redis->get($key);
        $this->redis->set($key, $current + 1); // lost update при параллельных вызовах
    }

    // Идиоматично через INCR (atomic на уровне Redis):
    public function safeIncrement(string $key): int
    {
        return $this->redis->incr($key); // одна операция, atomic
    }
}