Concurrency

Wat is concurrency?

Wanneer je meerdere taken die niet van elkaar afhankelijk zijn — zoals requests naar meerdere externe API’s of database-aggregaties — na elkaar uitvoert, is de totale tijd de som van alle afzonderlijke verwerkingstijden. Voer je ze tegelijk uit, dan wordt de totale tijd teruggebracht tot die van de langzaamste taak. Laravels Concurrency-facade maakt zulke parallelle uitvoering mogelijk met een eenvoudige API.

De Concurrency-facade is geïntroduceerd in Laravel 11 en is ook in Laravel 13 nog beschikbaar. De standaarddriver gebruikt PHP-childprocessen en werkt dus zonder extra packages.

Hoe het werkt

De Concurrency-facade serialiseert de doorgegeven closures, stuurt ze naar een verborgen Artisan-commando en voert ze elk uit in een apart PHP-proces. Zodra de verwerking klaar is, wordt de returnwaarde geserialiseerd en teruggestuurd naar het parent-proces. Er zijn drie drivers beschikbaar.

Driver	Beschrijving
`process`	Standaard. Start PHP-childprocessen. Werkt ook binnen webrequests
`fork`	Vereist het `spatie/fork`-package. Forkt processen en werkt daarom alleen via de CLI, maar is sneller
`sync`	Voert niet parallel maar sequentieel uit. Geschikt voor tests

Basisgebruik

Concurrency::run()

Als je een array van closures aan de run()-methode doorgeeft, worden deze parallel uitgevoerd. Als resultaat ontvang je een array met de returnwaarden van elke closure.

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

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

Met array-destructuring kun je elk resultaat in een variabele opvangen. De volgorde van de closures en de volgorde van de returnwaarden komen overeen.

Een driver kiezen

Wil je een specifieke driver gebruiken, dan geef je die op met de driver()-methode.

$results = Concurrency::driver('fork')->run([
    fn () => fetchFromApiA(),
    fn () => fetchFromApiB(),
]);

Om de standaarddriver te wijzigen, publiceer je het configuratiebestand en pas je de default-optie aan.

php artisan config:publish concurrency

De fork-driver gebruiken

De fork-driver is sneller dan de process-driver, maar kan alleen worden gebruikt in de PHP CLI-omgeving (Artisan-commando’s en queue workers). Binnen webrequests kun je hem niet gebruiken. Installeer vóór gebruik het spatie/fork-package.

composer require spatie/fork

De fork-driver werkt niet tijdens webrequests. Gebruik hem als je parallelle verwerking wilt uitvoeren binnen Artisan-commando’s of queue workers.

Geen resultaat nodig: Concurrency::defer()

Als je niet geïnteresseerd bent in het resultaat en de taken op de achtergrond wilt uitvoeren nadat de HTTP-response is verstuurd, gebruik je de defer()-methode.

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

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

Op het moment dat je defer() aanroept, worden de closures nog niet uitgevoerd. Ze worden parallel uitgevoerd nadat de HTTP-response naar de gebruiker is verzonden.

defer() is ideaal voor taken waarop de gebruiker niet hoeft te wachten, zoals het vastleggen van analytics-data of het opwarmen van de cache.

Praktijkvoorbeeld: meerdere externe API’s tegelijk aanroepen

Neem als voorbeeld een dashboard van een webshop dat informatie ophaalt uit drie API’s: voorraadbeheer, verkoopcijfers en verzendstatus.

Sequentiële uitvoering (vóór verbetering)

use Illuminate\Support\Facades\Http;

public function dashboard(): array
{
    // Wachten tot elk request na elkaar is afgerond (totaal circa 3 seconden)
    $inventory = Http::get('https://api.example.com/inventory')->json();
    $sales     = Http::get('https://api.example.com/sales')->json();
    $shipping  = Http::get('https://api.example.com/shipping')->json();

    return compact('inventory', 'sales', 'shipping');
}

Parallelle uitvoering (na verbetering)

use Illuminate\Support\Facades\Concurrency;
use Illuminate\Support\Facades\Http;

public function dashboard(): array
{
    // De drie requests tegelijk uitvoeren (klaar in de tijd van de traagste API)
    [$inventory, $sales, $shipping] = Concurrency::run([
        fn () => Http::get('https://api.example.com/inventory')->json(),
        fn () => Http::get('https://api.example.com/sales')->json(),
        fn () => Http::get('https://api.example.com/shipping')->json(),
    ]);

    return compact('inventory', 'sales', 'shipping');
}

Als elke API 1 seconde nodig heeft, duurt sequentiële uitvoering in totaal 3 seconden, terwijl parallelle uitvoering in ongeveer 1 seconde klaar is.

Meerdere database-aggregaties tegelijk uitvoeren

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

public function statistics(): array
{
    [$totalUsers, $activeUsers, $totalOrders, $revenue] = Concurrency::run([
        fn () => DB::table('users')->count(),
        fn () => DB::table('users')->where('active', true)->count(),
        fn () => DB::table('orders')->count(),
        fn () => DB::table('orders')->sum('total_amount'),
    ]);

    return [
        'total_users'  => $totalUsers,
        'active_users' => $activeUsers,
        'total_orders' => $totalOrders,
        'revenue'      => $revenue,
    ];
}

Als je de process-driver gebruikt voor database-aggregaties, wordt er per childproces een nieuwe databaseverbinding opgezet. Let bij veel gelijktijdige uitvoeringen op het maximale aantal databaseverbindingen.

Automatische propagatie van Context

In Laravel 13.31 (#61419) is de process-driver zo aangepast dat hij de huidige Context automatisch doorgeeft aan childprocessen. Voorheen werden waarden die met Context::add() waren ingesteld niet overgenomen door childprocessen die met Concurrency::run() of Concurrency::defer() werden gestart, waardoor de context in de logs van het parent- en het childproces uit elkaar kon lopen. Na de fix wordt intern hetzelfde mechanisme gebruikt als voor het doorgeven van context aan queue-jobs.

Vlak voordat het childproces wordt gestart, wordt het resultaat van Context::dehydrate() naar JSON geserialiseerd en als de omgevingsvariabele __LARAVEL_CONTEXT doorgegeven
Zodra het childproces (het verborgen Artisan-commando invoke-serialized-closure) start, wordt __LARAVEL_CONTEXT uitgelezen en met hydrate() in de Context-repository geladen

Daardoor kun je binnen de closure zonder problemen de context gebruiken die je erbuiten hebt ingesteld.

use Illuminate\Support\Facades\Concurrency;
use Illuminate\Support\Facades\Context;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;

Context::add('request_id', (string) Str::uuid());

Concurrency::run([
    function () {
        // De request_id die in het parentproces is ingesteld, is hier onverkort beschikbaar
        Log::info('inventory fetched', ['request_id' => Context::get('request_id')]);

        return Http::get('https://api.example.com/inventory')->json();
    },
]);

De fork-driver gebruikt de OS-fork() van spatie/fork, waardoor het childproces met een exacte kopie van de geheugenruimte van het parentproces start. De context wordt daardoor van nature al gedeeld, en deze fix heeft dus vooral betrekking op de process-driver (die een apart proces opstart).

Door waarden als request-ID’s en user-ID’s — die je gebruikt voor logcorrelatie — in Context te zetten, kun je ook de logs van parallel uitgevoerde processen met Concurrency::run() op dezelfde sleutels terugvinden. Zie de context delen voor meer details.

Configuratie voor tests

In de testomgeving voert de sync-driver de closures sequentieel uit. Er zijn geen opstartkosten voor processen, waardoor je tests sneller worden.

// tests/Feature/DashboardTest.php
use Illuminate\Support\Facades\Concurrency;

public function test_dashboard_returns_correct_data(): void
{
    Concurrency::fake(); // Overschakelen naar de sync-driver

    $response = $this->get('/dashboard');

    $response->assertStatus(200);
}

Je kunt de standaarddriver ook wijzigen in .env.testing.

CONCURRENCY_DRIVER=sync

Aandachtspunten

Beperkingen van closures

Closures worden geserialiseerd en doorgegeven aan het childproces. Objecten die niet geserialiseerd kunnen worden (databaseverbindingen, file handles, resources enzovoort) kun je niet van buiten de closure capturen. Maak benodigde objecten binnen de closure opnieuw aan.

// NG: een Eloquent-model van buitenaf capturen
$user = User::find(1);
Concurrency::run([
    fn () => $user->orders()->count(), // Kan mogelijk niet geserialiseerd worden
]);

// OK: de data binnen de closure ophalen
$userId = 1;
Concurrency::run([
    fn () => Order::where('user_id', $userId)->count(),
]);

Overhead van de process-driver

De process-driver heeft opstartkosten voor childprocessen. Als de taak zelf heel kort is (enkele milliseconden of minder), levert parallelle uitvoering mogelijk geen snelheidswinst op. Parallellisatie loont vooral bij taken die 100 ms of langer duren, zoals HTTP-requests of database-aggregaties.

Beperkingen van de fork-driver

De fork-driver forkt PHP-processen en kan daarom niet worden gebruikt tijdens webrequests (FPM of Apache). Gebruik hem alleen binnen Artisan-commando’s of queue workers.

Omgaan met exceptions

Als er tijdens de parallelle uitvoering een exception optreedt, gooit run() die exception opnieuw. Wil je dat de andere taken doorgaan als één taak een exception veroorzaakt, gebruik dan try/catch binnen de closure.

Concurrency::run([
    function () {
        try {
            return Http::get('https://api.example.com/data')->json();
        } catch (\Exception $e) {
            return null; // Geef null terug bij een fout
        }
    },
]);

Volgende stap

Queues en jobs

Leer hoe je met queues en jobs taken asynchroon op de achtergrond uitvoert

Architectuur

Database

Eloquent

Beveiliging

Events

E-mail en notificaties

Betalingen

Asynchrone verwerking

Realtime communicatie

Taakplanning

Caching en optimalisatie

Internationalisatie

Bestanden en opslag

Debugging en monitoring

Console en CLI

Performance

Frontend

AI-ontwikkeling

Ontwikkelomgeving

Wat is concurrency?

Hoe het werkt

Basisgebruik

Concurrency::run()

Een driver kiezen

De fork-driver gebruiken

Geen resultaat nodig: Concurrency::defer()

Praktijkvoorbeeld: meerdere externe API’s tegelijk aanroepen

Sequentiële uitvoering (vóór verbetering)

Parallelle uitvoering (na verbetering)

Meerdere database-aggregaties tegelijk uitvoeren

Automatische propagatie van Context

Configuratie voor tests

Aandachtspunten

Volgende stap

Queues en jobs

​Wat is concurrency?

​Hoe het werkt

​Basisgebruik

​Concurrency::run()

​Een driver kiezen

​De fork-driver gebruiken

​Geen resultaat nodig: Concurrency::defer()

​Praktijkvoorbeeld: meerdere externe API’s tegelijk aanroepen

​Sequentiële uitvoering (vóór verbetering)

​Parallelle uitvoering (na verbetering)

​Meerdere database-aggregaties tegelijk uitvoeren

​Automatische propagatie van Context

​Configuratie voor tests

​Aandachtspunten

​Volgende stap

Queues en jobs

Wat is concurrency?

Hoe het werkt

Basisgebruik

Concurrency::run()

Een driver kiezen

De fork-driver gebruiken

Geen resultaat nodig: Concurrency::defer()

Praktijkvoorbeeld: meerdere externe API’s tegelijk aanroepen

Sequentiële uitvoering (vóór verbetering)

Parallelle uitvoering (na verbetering)

Meerdere database-aggregaties tegelijk uitvoeren

Automatische propagatie van Context

Configuratie voor tests

Aandachtspunten

Volgende stap