README

A standalone extraction of Laravel's Concurrency component for use outside of the full laravel/framework package.

Why does this package exist?

Laravel ships many of its components as standalone illuminate/* packages, allowing developers to use them in non-Laravel projects or micro-frameworks. However, the Concurrency component has not yet been split into its own illuminate/concurrency package — it only lives inside the monolithic laravel/framework repository.

This package extracts the Concurrency component exactly as it exists in laravel/framework, making it installable as a first-class Composer dependency without pulling in the entire framework.

Installation

composer require igorsgm/illuminate-concurrency

Optional: Before using the fork driver, you need to install the spatie/fork package:

composer require spatie/fork

Concurrency (from Laravel Docs)

Introduction

Sometimes you may need to execute several slow tasks which do not depend on one another. In many cases, significant performance improvements can be realized by executing the tasks concurrently. Laravel's Concurrency facade provides a simple, convenient API for executing closures concurrently.

How it Works

Laravel achieves concurrency by serializing the given closures and dispatching them to a hidden Artisan CLI command, which unserializes the closures and invokes it within its own PHP process. After the closure has been invoked, the resulting value is serialized back to the parent process.

The Concurrency facade supports three drivers:

Driver	Description	Requires
`process`	Runs tasks in parallel child processes (default)	—
`fork`	Uses `pcntl_fork` for true parallel execution. Offers improved performance compared to the default `process` driver, but it may only be used within PHP's CLI context, as PHP does not support forking during web requests.	`spatie/fork`, CLI only
`sync`	Primarily useful during testing when you want to disable all concurrency and simply execute the given closures in sequence within the parent process.	—

Running Concurrent Tasks

To run concurrent tasks, you may invoke the Concurrency facade's run method. The run method accepts an array of closures which should be executed simultaneously in child PHP processes:

use Illuminate\Support\Facades\Concurrency;
use Illuminate\Support\Facades\DB;

[$userCount, $orderCount] = Concurrency::run([
    fn () => DB::table('users')->count(),
    fn () => DB::table('orders')->count(),
]);

To use a specific driver, you may use the driver method:

$results = Concurrency::driver('fork')->run(...);

Or, to change the default concurrency driver, you should publish the concurrency configuration file via the config:publish Artisan command and update the default option within the file:

php artisan config:publish concurrency

Deferring Concurrent Tasks

If you would like to execute an array of closures concurrently, but are not interested in the results returned by those closures, you should consider using the defer method. When the defer method is invoked, the given closures are not executed immediately. Instead, Laravel will execute the closures concurrently after the HTTP response has been sent to the user:

use App\Services\Metrics;
use Illuminate\Support\Facades\Concurrency;

Concurrency::defer([
    fn () => Metrics::report('users'),
    fn () => Metrics::report('orders'),
]);

Source

This package mirrors the source code from:

License

The MIT License (MIT). See LICENSE.md for details.

igorsgm / illuminate-concurrency

Maintainers

Package info

Statistics

Security