Laravel Concurrency Facade & Process Pools | Mohamed Said       [Skip to content](#main)  [ ![](https://cdn.msaied.com/01KT78WE565VEMM3PSNQAAB0MH.png) Mohamed SaidLaravel Backend Engineer ](https://www.msaied.com/public) - [Home](https://www.msaied.com/public)
- [Projects](https://www.msaied.com/public/projects)
- [Articles](https://www.msaied.com/public/articles)
- [Certificates](https://www.msaied.com/public/certificates)
- [About](https://www.msaied.com/public#about)

           [  Contact](https://www.msaied.com/public#contact) Menu 

Menu
----

Close 

 - [HomeStart here](https://www.msaied.com/public)
- [ProjectsCase studies](https://www.msaied.com/public/projects)
- [ArticlesEngineering notes](https://www.msaied.com/public/articles)
- [CertificatesCredentials](https://www.msaied.com/public/certificates)
- [AboutHow I work](https://www.msaied.com/public#about)
- [ContactGet in touch](https://www.msaied.com/public#contact)

  [Start a conversation](https://www.msaied.com/public#contact) [WhatsApp](https://wa.me/201094619204) [Email](mailto:hello@msaied.com) 

 1. [Home](https://www.msaied.com/public)
2. /
3. [Articles](https://www.msaied.com/public/articles)
4. /
5. Laravel Concurrency Facade and Process Pools for Parallel Work

 Laravel Concurrency Facade and Process Pools for Parallel Work
===============================================================

 Laravel's Concurrency facade and process pools let you run independent tasks in parallel without reaching for a queue. Learn when to use each, how to avoid pitfalls, and how to structure real workloads.

 ![](https://cdn.msaied.com/01M22N44A70A5MC2S599JP0MPH.webp) [Mohamed Said](https://www.msaied.com/public#person) Published 14 Sep 2026 · Updated 14 Sep 2026 · 3 min read

ShareCopy linkCopied

 ![Laravel Concurrency Facade and Process Pools for Parallel Work](https://cdn.msaied.com/667/241195c7a202f534b71ced2e321e27b5.png) 

  On this page +1. [Running Tasks in Parallel with Laravel's Concurrency Facade](#running-tasks-in-parallel-with-laravels-concurrency-facade)
2. [The Two Drivers](#the-two-drivers)
3. [Basic Usage](#basic-usage)
4. [Choosing the Driver Explicitly](#choosing-the-driver-explicitly)
5. [Process Pools for Fan-Out Work](#process-pools-for-fan-out-work)
6. [Concurrency Limits](#concurrency-limits)
7. [What Not to Parallelize](#what-not-to-parallelize)
8. [Testing Parallel Code](#testing-parallel-code)
9. [Takeaways](#takeaways)

 Running Tasks in Parallel with Laravel's Concurrency Facade
-----------------------------------------------------------

Laravel ships a `Concurrency` facade that lets you execute multiple closures in parallel without spinning up a queue worker. Under the hood it forks the current PHP process (using the `fork` driver) or spawns isolated sub-processes (the `process` driver). Knowing which driver fits your workload is the first decision you need to make.

### The Two Drivers

| Driver | Mechanism | Shared memory | Best for | |--------|-----------|---------------|----------| | `fork` | `pcntl_fork` | No — copy-on-write | CPU-bound, short-lived | | `process` | `symfony/process` | No — separate PHP process | I/O-bound, DB calls, HTTP |

The `fork` driver is faster to spin up but is unavailable on Windows and inside FrankenPHP workers (where forking is unsafe). The `process` driver is portable and safer for anything that touches a database connection, because each child gets its own bootstrapped application.

### Basic Usage

```php
use Illuminate\Support\Facades\Concurrency;

[$users, $orders, $metrics] = Concurrency::run([
    fn () => User::whereActive()->count(),
    fn () => Order::wherePending()->sum('total'),
    fn () => Cache::get('dashboard.metrics'),
]);

```

`run()` blocks until every closure finishes and returns results in the same order. If any closure throws, the exception is re-thrown in the parent after all tasks complete.

### Choosing the Driver Explicitly

```php
// Force the process driver for DB-heavy work
$results = Concurrency::driver('process')->run([
    fn () => DB::table('events')->where('type', 'click')->count(),
    fn () => DB::table('events')->where('type', 'view')->count(),
]);

```

Always use `driver('process')` when closures open Eloquent connections. The `fork` driver inherits the parent's open PDO handles, and sharing a socket across processes causes protocol corruption.

### Process Pools for Fan-Out Work

When you have a *variable-length* list of tasks, reach for `Pool` directly:

```php
use Illuminate\Process\Pool;
use Illuminate\Support\Facades\Process;

$results = Process::pool(function (Pool $pool) use ($tenantIds) {
    foreach ($tenantIds as $id) {
        $pool->command("php artisan tenants:sync {$id}");
    }
})->start()->wait();

foreach ($results as $result) {
    if ($result->failed()) {
        Log::error($result->errorOutput());
    }
}

```

Process pools are ideal for running Artisan commands or shell scripts in parallel. Each process is fully isolated — no shared state, no memory leaks back to the parent.

### Concurrency Limits

Unbounded parallelism will exhaust file descriptors and memory. Chunk your work:

```php
$chunks = collect($tenantIds)->chunk(10);

foreach ($chunks as $chunk) {
    Concurrency::driver('process')->run(
        $chunk->map(fn ($id) => fn () => app(TenantSyncAction::class)->execute($id))->all()
    );
}

```

This keeps at most 10 processes alive at once, which is a safe ceiling for most VPS deployments.

### What Not to Parallelize

- **Tasks that share a writable resource** (same cache key, same file) without a lock.
- **Tasks shorter than ~5 ms** — process spawn overhead will dominate.
- **Tasks inside Octane workers** using the `fork` driver — Octane's persistent state makes forking dangerous.

### Testing Parallel Code

The `Concurrency` facade is fakeable:

```php
Concurrency::fake();

// Closures run sequentially in the test process
$results = Concurrency::run([
    fn () => 'a',
    fn () => 'b',
]);

expect($results)->toBe(['a', 'b']);

```

Faking forces sequential execution, which makes assertions deterministic and keeps your CI pipeline single-process.

### Takeaways

- Use `Concurrency::run()` for a fixed set of independent closures; use `Process::pool()` for dynamic fan-out.
- Always pick `driver('process')` when closures touch the database.
- Chunk large workloads to cap concurrency and prevent resource exhaustion.
- Fake the facade in tests to keep assertions deterministic.
- Avoid `fork` inside Octane or FrankenPHP workers.

- [laravel](https://www.msaied.com/public/articles?search=laravel)
- [concurrency](https://www.msaied.com/public/articles?search=concurrency)
- [performance](https://www.msaied.com/public/articles?search=performance)
- [php](https://www.msaied.com/public/articles?search=php)

 Frequently asked questions 
---------------------------

  Can I use the Concurrency facade inside a queued job?Yes, but prefer the `process` driver. Queue workers are long-lived processes, and forking inside them can cause unexpected behavior with open connections. The `process` driver spawns a completely fresh PHP process, which is safe regardless of the parent's state.

   How does error handling work when one concurrent task fails?With `Concurrency::run()`, all tasks run to completion before any exception is surfaced. The first exception encountered is re-thrown in the calling process. If you need per-task error handling, wrap each closure in a try/catch and return a result object instead of throwing.

   Is there a performance benefit over queues for short-lived parallel work?Yes. Queues introduce serialization, network round-trips to Redis or SQS, and worker polling latency. For work that must complete within the current request or command and takes under a few seconds total, the Concurrency facade is significantly lower overhead.

   ![Mohamed Said](https://cdn.msaied.com/01M22N44A70A5MC2S599JP0MPH.webp)About the author
----------------

[Mohamed Said](https://www.msaied.com/public#person)Senior Backend Engineer specializing in Laravel, scalable SaaS platforms, APIs, and cloud infrastructure. I build secure, high-performance web applications that help businesses grow.

[About](https://www.msaied.com/public#about) [GitHub ↗](https://github.com/EG-Mohamed) [LinkedIn ↗](https://www.linkedin.com/in/msaiedm/) [WhatsApp ↗](https://wa.me/201094619204) [Email Address ↗](mailto:hello@msaied.com) [My CV ↗](https://drive.google.com/file/u/0/d/1MF20IPRJyzfy32mhEutjL5EpSls0w2Q8/view)  

   [Previous articleJob Batching, Chaining, and Catch Callbacks: Reliable Async Workflows in Laravel](https://www.msaied.com/public/articles/job-batching-chaining-and-catch-callbacks-reliable-async-workflows-in-laravel) [Next articleLivewire v4.4.5 Released: wire:navigate Fixes, JSON Session Support & More](https://www.msaied.com/public/articles/livewire-v445-released-wirenavigate-fixes-json-session-support-more)  

   On this page
-------------

1. [Running Tasks in Parallel with Laravel's Concurrency Facade](#running-tasks-in-parallel-with-laravels-concurrency-facade)
2. [The Two Drivers](#the-two-drivers)
3. [Basic Usage](#basic-usage)
4. [Choosing the Driver Explicitly](#choosing-the-driver-explicitly)
5. [Process Pools for Fan-Out Work](#process-pools-for-fan-out-work)
6. [Concurrency Limits](#concurrency-limits)
7. [What Not to Parallelize](#what-not-to-parallelize)
8. [Testing Parallel Code](#testing-parallel-code)
9. [Takeaways](#takeaways)

 ###  Have a technical challenge?

 Tell me what you’re building. I reply within two working days.

[Start a conversation](https://www.msaied.com/public#contact) 

   Related articles
-----------------

 [ ![](https://cdn.msaied.com/740/cce86edc21eddcbdd2f2454fadaf9c70.png)  · 3 min read### The Pipeline Pattern in Laravel: Custom Pipelines Beyond Middleware

5 Oct 2026 ](https://www.msaied.com/public/articles/the-pipeline-pattern-in-laravel-custom-pipelines-beyond-middleware-1) [ ![](https://cdn.msaied.com/739/2d6897fdcdcf090613f96f72a64b8a78.png)  · 4 min read### MySQL Full-Text Search in Laravel: Indexes, Relevance Scoring, and Boolean Mode

4 Oct 2026 ](https://www.msaied.com/public/articles/mysql-full-text-search-in-laravel-indexes-relevance-scoring-and-boolean-mode) [ ![](https://cdn.msaied.com/738/073696a3fefe18bec825beec5ac658f5.png)  · 4 min read### Laravel Queue Rate-Limited Middleware: Throttling Jobs Without Losing Work

4 Oct 2026 ](https://www.msaied.com/public/articles/laravel-queue-rate-limited-middleware-throttling-jobs-without-losing-work) 

  Have a technical challenge?
----------------------------

Tell me what you’re building. I reply within two working days.

 [Discuss your project ↗](https://www.msaied.com/public#contact) 

  © 2026 Mohamed Said · Built with Laravel, meant to last.Senior Backend Engineer specializing in Laravel, scalable SaaS platforms, APIs, and cloud infrastructure. I build secure, high-performance web applications that help businesses grow.

 - [Home](https://www.msaied.com/public)
- [Articles](https://www.msaied.com/public/articles)
- [Certificates](https://www.msaied.com/public/certificates)
- [GitHub](https://github.com/EG-Mohamed)
- [LinkedIn](https://www.linkedin.com/in/msaiedm/)
- [WhatsApp](https://wa.me/201094619204)
- [Email Address](mailto:hello@msaied.com)
- [My CV](https://drive.google.com/file/u/0/d/1MF20IPRJyzfy32mhEutjL5EpSls0w2Q8/view)
- [Sitemap](https://www.msaied.com/public/sitemap.xml)