Memory leak in Swoole workers — static variables survive between requests

nphp14 May 2026 22:01

Ran into a nasty issue last week. Our Hyperf app started eating RAM after about 2–3 hours of traffic, workers had to be restarted manually.

After profiling with swoole_tracemalloc and reading through the code carefully, we found the root cause: static class properties that we were using as in-memory caches were never reset between requests because Swoole reuses the same PHP process for thousands of requests — unlike PHP-FPM where each request is a clean process.

Example of the problem:

PHP

1
2
3
4
5
6
7
8
9
10
11
12
class CategoryRepository
{
    private static array $cache = [];
    public function find(int $id): Category
    {
        if (!isset(self::$cache[$id])) {
            self::$cache[$id] = Category::query()->find($id);
        }
        return self::$cache[$id];
    }
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

This cache grows indefinitely. In FPM it resets on every request. In Swoole it lives for the lifetime of the worker.

We ended up switching to coroutine-local storage using Swoole\Coroutine::getContext() for request-scoped caches, and moved longer-lived caches to Redis with TTLs.

But I am still not 100% sure this is the only place. Are there other common patterns that cause leaks in long-running Swoole apps? Curious what others have encountered.

1209

Replies (2)

simondev14 May 2026 22:48

Yeah, had exactly the same thing. Static variables are the most common one, but there are others:

Event listeners registered globally inside a request handler — if you register them in a service that gets instantiated per-request, listeners pile up on the same dispatcher instance
Unclosed generators — not GC’d immediately in coroutine context
Guzzle with persistent connections improperly configured — connection pool grows unbounded

For the static cache case specifically, Hyperf’s Coroutine::getContext() approach is correct. Something like:

PHP

1
2
3
4
5
6
7
8
9
10
11
private function getCache(): array
{
    $ctx = Coroutine::getContext();
    return $ctx[self::class] ?? [];
}
private function setCache(array $data): void
{
    $ctx = Coroutine::getContext();
    $ctx[self::class] = $data;
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Context is automatically destroyed when the coroutine ends, so no leaks.

bohdan_v15 May 2026 01:06

One more thing worth checking — Hyperf\Utils\Context is the Hyperf-idiomatic wrapper around exactly that coroutine context, you don’t need to use the Swoole API directly:

PHP

1
2
3
4
5
6
7
use Hyperf\Utils\Context;
$cached = Context::get(self::class . '::cache');
if ($cached === null) {
    $cached = $this->loadFromDb();
    Context::set(self::class . '::cache', $cached);
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Also, check your DB connection pool config. If max_connections is set too high and connections are not released properly (exception thrown before finally), that’s another slow leak that shows up under load. We set up a cron that logs pool stats every 5 minutes to catch this early.

Write a reply