Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:129746
Precedence: list
MIME-Version: 1.0
Date: Sat, 10 Jan 2026 11:19:07 +0300
Message-ID: <CAE6GH03pVxstk8ssJhMfMTT-=S+3+Usk=7g1CarCb+NBB_7TDw@mail.gmail.com>
Subject: [PHP-DEV] Analogue of Node.js Worker threads?
To: internals internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="000000000000587fef0648044cd5"
From: pacha.shevaev@gmail.com (Pavel Shevaev)

--000000000000587fef0648044cd5
Content-Type: text/plain; charset="UTF-8"

Hi!

Historically in my company PHP has been used as a CLI tool for project
building purposes. For example for code generation, configs parsing and
converting them into binary blobs, calling dotnet and go tools, etc. In
general it's a cross platform 'make on steroids'.

We are pretty much happy about it except one particular thing: convenient
cross platform multi-threading. And we don't actually need a true
multi-threading but rather something similar to Worker threads in Node.js.

We tried using the AMPHP Parallel package but it wasn't stable enough for
our needs (hangs or emits serialization errors for our workloads). And it
also seems to be using a special 'ProcessWrapper.exe' (bundled with a
composer package) to overcome some Window specific issues. Due to strict
anti-virus policies we had to manually add an exception for it... So we
ended up with some primitive wrappers around platform specific tools: for
*nix we start background PHP processes with '&', for Windows - using
'powershell.exe Start-Process' for the same purpose. We pass data to and
from these background processes using serialization and temporary files and
while it works, well, it's pretty inconvenient and cumbersome.

Out of curiosity I tried Node.js Worker threads and it just worked as
expected for our sample loads both on *nix and Windows boxes. And there are
some high-level wrappers over Worker threads like Piscina which simplify
things even further:

    const worker = new Piscina({
      filename: path.resolve(__dirname, "worker.js"),
      maxThreads: 32,
      maxQueue: "auto",
    });

    const results = await Promise.all(
      files.map((file, idx) => worker.run([file]))
    )

I think PHP could benefit from having the similar 'multi-processing'
support in the core. It seems like here's what Node.js does:
1) Spawns/stops worker threads
2) Passes serialized input/output between the worker manager and worker
threads

Since worker threads are fully isolated you can't directly access their
internal data, there are no data races and there's no need for any
synchronization primitives.

I guess PHP could do the same even in non ZTS mode? And the aforementioned
AMPHP could use this built-in Worker threads support without having to
resort to any platform specific hacks providing a nice and clean
interface.


-- 
Best regards, Pavel

--000000000000587fef0648044cd5
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>Hi!</div><div><br></div><div>Historically in my compa=
ny PHP has been used as a CLI tool for project building purposes. For examp=
le for code generation, configs parsing and converting them into binary blo=
bs, calling dotnet and go tools, etc. In general it&#39;s a cross platform =
&#39;make on steroids&#39;.=C2=A0</div><div><br></div><div>We are pretty mu=
ch happy about it except one particular thing: convenient cross platform mu=
lti-threading. And we don&#39;t actually need a true multi-threading but ra=
ther something similar to Worker threads in Node.js. <br><br>We tried using=
 the AMPHP Parallel package but it wasn&#39;t stable enough for our=C2=A0ne=
eds (hangs or emits serialization errors for our=C2=A0workloads). And it al=
so seems to be using a special &#39;ProcessWrapper.exe&#39; (bundled with a=
 composer package) to overcome some Window specific=C2=A0issues. Due to str=
ict anti-virus policies we had to manually add an exception for it... So we=
 ended up with some primitive wrappers around platform specific tools: for =
*nix we start background PHP processes with &#39;&amp;&#39;, for Windows - =
using &#39;powershell.exe Start-Process&#39; for the same purpose. We pass =
data to and from these background processes using serialization and tempora=
ry=C2=A0files and while it works, well, it&#39;s pretty inconvenient and cu=
mbersome.=C2=A0=C2=A0<br><br>Out=C2=A0of curiosity I tried Node.js Worker t=
hreads and it just worked as expected for our sample loads both on *nix and=
 Windows boxes. And there are some high-level wrappers over Worker threads =
like Piscina which simplify things even further:<br><br>=C2=A0 =C2=A0 const=
 worker =3D new Piscina({<br>=C2=A0 =C2=A0 =C2=A0 filename: path.resolve(__=
dirname, &quot;worker.js&quot;),<br>=C2=A0 =C2=A0 =C2=A0 maxThreads: 32,<br=
>=C2=A0 =C2=A0 =C2=A0 maxQueue: &quot;auto&quot;,<br>=C2=A0 =C2=A0 });<br><=
br>=C2=A0 =C2=A0 const results =3D await Promise.all(<br>=C2=A0 =C2=A0 =C2=
=A0 files.map((file, idx) =3D&gt; worker.run([file]))<br>=C2=A0 =C2=A0 )<br=
><br></div><div>I think PHP could benefit from having the similar &#39;mult=
i-processing&#39; support in the core. It seems like here&#39;s what Node.j=
s does:<br>1) Spawns/stops worker threads<br>2) Passes serialized input/out=
put between the worker manager and worker threads<br><br>Since worker threa=
ds are fully isolated you can&#39;t directly access their internal data, th=
ere are no data races and there&#39;s no need for any synchronization primi=
tives. <br><br>I guess PHP could do the same even in non ZTS mode? And the =
aforementioned AMPHP could use this built-in Worker threads support without=
 having to resort to any platform specific hacks providing a nice and clean=
 interface.=C2=A0=C2=A0<br><br><br></div><span class=3D"gmail_signature_pre=
fix">-- </span><br><div dir=3D"ltr" class=3D"gmail_signature" data-smartmai=
l=3D"gmail_signature">Best regards, Pavel</div></div>

--000000000000587fef0648044cd5--