Handling Process Synchronization with Laravel Cache Locks

Managing concurrent operations in applications requires careful synchronization to prevent conflicts. Laravel's cache locking mechanism offers a robust solution for this, effectively handling scenarios like file uploads, webhook processing, and background tasks. This system creates distributed locks, functioning seamlessly across multiple servers, processes, and queue workers, thus preventing race conditions in distributed environments.

Here's how to implement a cache lock:

use Illuminate\Support\Facades\Cache;

$lock = Cache::lock('process-payment', 120); // Creates a lock named 'process-payment' lasting 120 seconds

if ($lock->get()) {
    // Payment processing logic here.  The lock is automatically released after 120 seconds.
}

Let's illustrate with a practical example of webhook handling:

<?php namespace App\Http\Controllers;

use Illuminate\Support\Facades\Cache;
use App\Jobs\ProcessWebhook;
use Illuminate\Http\Request;
use Log;
use Exception;

class WebhookController extends Controller
{
    public function handle(Request $request)
    {
        $webhookId = $request->input('webhook_id');
        $lockName = "webhook-{$webhookId}";

        $lock = Cache::lock($lockName, 60);

        try {
            if (!$lock->get()) {
                Log::info("Webhook {$webhookId} is already being processed");
                return response()->json(['message' => 'Webhook is being processed'], 409);
            }

            $this->validateWebhook($request); // Validation step

            ProcessWebhook::dispatch($request->all(), $lock->owner())->onQueue('webhooks');

            return response()->json(['message' => 'Webhook accepted', 'processing_id' => $lock->owner()]);

        } catch (Exception $e) {
            $lock?->release();
            throw $e;
        }
    }
}

class ProcessWebhook implements ShouldQueue
{
    public function __construct(private array $payload, private string $lockOwner) {}

    public function handle()
    {
        $lock = Cache::restoreLock("webhook-{$this->payload['webhook_id']}", $this->lockOwner);

        try {
            $this->processWebhookPayload(); // Webhook processing logic

        } finally {
            $lock->release(); // Ensure lock release even on errors
        }
    }
}

This example demonstrates how to acquire a lock, process the webhook within a protected block, and reliably release the lock, ensuring data integrity even under concurrent requests. Laravel's cache locks provide a dependable mechanism for managing concurrent processes and maintaining application stability.

The above is the detailed content of Handling Process Synchronization with Laravel Cache Locks. For more information, please follow other related articles on the PHP Chinese website!