Crea dashboard velocissime con Laravel: esecuzione di processi concorrenti

Nelle moderne applicazioni web, la velocità non è un lusso, bensì un requisito imprescindibile.

Gli utenti desiderano che le dashboard si carichino istantaneamente, che le analisi si aggiornino in tempo reale e che i report vengano generati senza ritardi.

Tuttavia, molte applicazioni Laravel continuano ad avere problemi di prestazioni.

Il motivo?

La maggior parte delle operazioni viene eseguita in sequenza .

Il problema dell’esecuzione sequenziale

Una dashboard Laravel tipica potrebbe svolgere le seguenti funzioni:

• Query di espansione
• chiamate API
• Aggregazione dei dati
• Calcoli

Solitamente tutte queste attività si susseguono una dopo l’altra.

$userStats = $this->fetchUserStats($userId);
$recentOrders = $this->fetchRecentOrders($userId);
$apiData = $this->fetchExternalApiData($userId);

Se ogni task richiede:

• 300 ms
• 500 ms
• 700 ms

allora il totale dell’esecuzione sarà 1,5 secondi

Quel ritardo si accumula rapidamente, soprattutto su larga scala.

Scopri la concorrenza in Laravel

Laravel 10 ha introdotto una potente funzionalità:

Concurrency::run()

Consente di eseguire più attività in parallelo all’interno della stessa richiesta, senza code.

Come funziona

use Illuminate\Support\Facades\Concurrency;

$results = Concurrency::run([
    fn () => $this->fetchUserStats($userId),
    fn () => $this->fetchRecentOrders($userId),
    fn () => $this->fetchExternalApiData($userId),
]);

Invece di aspettare ogni singola attività:

• Tutte le attività vengono eseguite contemporaneamente
• I risultati vengono restituiti in ordine

L’impatto sulle prestazioni

Stessi task:

• 300 ms
• 500 ms
• 700 ms

il tempo di esecuzione totale sarà il tempo di esecuzione più lungo: 700 ms (non 1,5 s)

Ciò significa un’accelerazione superiore al 50% , con un miglioramento immediato dell’esperienza utente.

Perché è importante

1. Dashboard più veloci

Tutti i widget vengono caricati simultaneamente anziché attendere in coda.

2. Chiamate API parallele

Basta con le richieste a catena, lente.

3. Codice più pulito

Nessuna logica asincrona complessa o configurazione di code.

4. Esperienza in tempo reale

Tutto avviene con una singola richiesta.

Casi d’uso reali

Dashboard di analisi

$data = Concurrency::run([
    fn () => Orders::today()->count(),
    fn () => Users::active()->count(),
    fn () => Revenue::monthly()->sum('amount'),
]);

Aggregazione di API esterne

$stocks = Concurrency::run([
    fn () => Http::get('https://api1.com'),
    fn () => Http::get('https://api2.com'),
    fn () => Http::get('https://api3.com'),
]);

Generazione di report

$report = Concurrency::run([
    fn () => $this->calculateSales($month),
    fn () => $this->calculateExpenses($month),
    fn () => $this->calculateProfit($month),
]);

Quando utilizzare la concorrenza

Ideale per:

• Query di espansione
• richieste API
• Operazioni sui file
• Aggregazioni

Evitare per:

• Attività che richiedono un elevato utilizzo della CPU
• Lavori di lunga durata

Gestire gli errori in modo sicuro

fn () => try {
    return $this->fetchApi();
} catch (\Exception $e) {
    return null;
}

Limitare le attività parallele

Un numero eccessivo di operazioni simultanee può sovraccaricare il server.

Usalo in modo strategico

Non tutto richiede la concorrenza: usatela dove la latenza è un fattore critico.

Quando NON usarlo

La concorrenza è potente, ma:

• Non sostituisce le code
• Non gestisce i processi in background
• Può aumentare il consumo di risorse

Utilizza le code quando hai bisogno di un’elaborazione differita .