Image de couverture : Laravel : empêcher qu'une même course soit acceptée par deux chauffeurs
PHP & Frameworks

Laravel : empêcher qu'une même course soit acceptée par deux chauffeurs

5 min de lecture
40 vues
Sébastien Muler

Deux chauffeurs, une seule course : que se passe-t-il quand les requêtes arrivent en même temps ?

Un chauffeur appuie sur « Accepter », un deuxième fait de même dans la même seconde. Les deux téléphones affichent une confirmation verte. Aucune erreur dans les logs, aucune exception : chaque requête, prise isolément, s'est parfaitement bien déroulée. Pourtant la course est attribuée deux fois. Ce défaut porte un nom, la condition de concurrence (race condition), et tout workflow de type « premier arrivé, premier servi » (dispatch, réservation, prise en charge d'une tâche) y est exposé dès que le trafic devient réel.

L'article de blog Laravel Race Condition Fix: Stop Double-Accepted Jobs décrit ce scénario sur une plateforme de logistique dont l'API est en Laravel. Voici notre lecture du problème et des parades, adaptée à ce que l'on rencontre sur des projets PHP.

Pourquoi le code « évident » échoue

Le réflexe est d'écrire trois étapes : lire la course, vérifier qu'elle est encore en attente, puis l'affecter au chauffeur.

public function accept(Request $request, Delivery $delivery)
{
    $driver = $request->user();

    if ($delivery->status !== 'pending') {
        return response()->json(['message' => 'Déjà prise'], 409);
    }

    $delivery->update([
        'status' => 'accepted',
        'driver_id' => $driver->id,
    ]);

    return response()->json(['message' => 'Course acceptée']);
}

En test avec un seul utilisateur, tout fonctionne. Sous concurrence, le défaut apparaît dans l'intervalle entre la lecture et l'écriture : les deux requêtes lisent le statut pending avant que l'une d'elles ait eu le temps de le modifier. Les deux passent la vérification, les deux écrivent, et la dernière écriture écrase la première. Le chauffeur « perdant » a pourtant reçu une confirmation.

Le point clé : la vérification et l'écriture ne sont pas atomiques. Tant qu'un autre processus peut s'intercaler entre les deux, aucune condition if en PHP ne vous protège, car la vérité se trouve dans la base de données, pas en mémoire.

Les parades côté base de données

Plusieurs approches permettent de rendre l'opération atomique. Elles ont toutes le même principe : déléguer l'arbitrage à la base, seule à voir toutes les requêtes en même temps.

Le verrouillage pessimiste avec lockForUpdate

On ouvre une transaction, on relit la ligne en la verrouillant, puis on vérifie et on écrit. Toute autre transaction qui tente de lire la même ligne avec un verrou attend la fin de la première.

use Illuminate\Support\Facades\DB;

$accepted = DB::transaction(function () use ($delivery, $driver) {
    $locked = Delivery::whereKey($delivery->id)
        ->lockForUpdate()
        ->first();

    if ($locked->status !== 'pending') {
        return false;
    }

    $locked->update([
        'status' => 'accepted',
        'driver_id' => $driver->id,
    ]);

    return true;
});

Le second chauffeur attend que la transaction du premier se termine, relit alors le statut accepted, et reçoit un refus propre. C'est l'option la plus lisible quand la logique métier entre la lecture et l'écriture est riche (calculs, vérifications multiples).

La mise à jour conditionnelle atomique

Plus économe, on fusionne la vérification et l'écriture dans une seule requête SQL :

$affected = Delivery::where('id', $delivery->id)
    ->where('status', 'pending')
    ->update([
        'status' => 'accepted',
        'driver_id' => $driver->id,
    ]);

if ($affected === 0) {
    return response()->json(['message' => 'Déjà prise'], 409);
}

Le nombre de lignes affectées sert de verdict : un seul chauffeur obtient 1, les autres obtiennent 0. Pas de verrou explicite à gérer, pas de transaction obligatoire pour ce cas simple. C'est souvent le premier réflexe à privilégier quand la règle tient en une condition.

Le verrouillage optimiste et les contraintes d'unicité

Deux variantes complètent la boîte à outils :

  • Le verrouillage optimiste ajoute une colonne de version, incrémentée à chaque modification. L'écriture ne réussit que si la version n'a pas changé depuis la lecture. Il convient bien quand les conflits sont rares.
  • Une contrainte d'unicité en base, par exemple une table d'attributions où delivery_id est unique, fait échouer toute seconde insertion. Le conflit devient une exception à intercepter, ce qui offre un filet de sécurité très robuste, car il tient même si le code applicatif comporte un oubli.

Le choix dépend du contexte, mais le principe reste le même : la règle « un seul gagnant » doit être garantie par la base, pas seulement par le code PHP.

Prouver que le correctif fonctionne

Un correctif de concurrence qui n'est pas testé sous concurrence n'est qu'une hypothèse. Un test unitaire séquentiel passera avant comme après la correction, ce qui le rend inutile ici. Quelques pistes :

  • Lancer plusieurs requêtes réellement parallèles (par exemple avec un outil de charge ou plusieurs processus) sur la même course, et vérifier qu'une seule obtient un succès.
  • Contrôler en base qu'il n'existe qu'un seul driver_id associé à la course à l'issue du test.
  • Rejouer le test plusieurs fois : une condition de concurrence peut se manifester une fois sur dix seulement.
  • Vérifier que les réponses des perdants sont bien des refus explicites (un code 409 par exemple), et non des erreurs 500 dues à un blocage ou à une contrainte violée.

Pensez aussi aux effets de bord : notifications, événements, jobs en file d'attente. Ils ne doivent partir qu'après la validation de la transaction, sans quoi le perdant pourrait recevoir un message de confirmation pour une course qu'il n'a pas obtenue.

À retenir

Une vérification de statut suivie d'une écriture, sans protection, laisse toujours une fenêtre de conflit. Pour la refermer, le plus simple est souvent une mise à jour conditionnelle atomique, le lockForUpdate convient aux traitements plus riches, et une contrainte d'unicité offre un dernier rempart. Quelle que soit l'option retenue, validez-la par un test réellement concurrent.

Ce que ça change pour vous

Si votre activité repose sur un principe du type « le premier qui réserve l'obtient », deux clients ou deux collaborateurs peuvent se voir confirmer la même chose au même instant, sans que rien n'alerte personne. Le résultat : un client mécontent, un déplacement inutile, du temps perdu à démêler la situation. Ce défaut se corrige une fois pour toutes en faisant arbitrer la base de données plutôt que l'application, à condition de le vérifier avec des tests qui simulent de vrais accès simultanés.

Partager cet article

Et votre site, il vaut quoi ?

Vitesse, accessibilité, référencement technique. Le rapport est écrit pour un dirigeant, pas pour un développeur. Gratuit, sans inscription.

Tester mon site