In wettbewerbsintensiven Anwendungen sind Rennbedingungen die stillschweigenden Killer der Datenintegrität.Ob es sich um die Verhinderung von Doppelbuchungen in einem Buchungssystem handelt, um sicherzustellen, dass eine cron-Arbeit auf nur einem Server ausgeführt wird, oder um die API-Nutzung zu verhindern, die Es ist Ihre erste Verteidigungslinie. Symfony Lock Component Mit der Freilassung des , das Ökosystem reif geworden ist, bietet saubere Attribute, eine bessere Integration mit cloud-nativen Stores (wie Dieser Artikel deckt die best Practices ab, die ich in der Produktion benutze, um sicherzustellen, dass Ihre Anwendung robust und deadlock-frei bleibt. Symfony 7.4 DynamoDB Installation und Konfiguration Beginnen Sie mit der Installation der Komponente. Wir verwenden den Standard Wenn Sie vorhaben, Redis (empfohlen für verteilte Systeme) zu verwenden, stellen Sie sicher, dass Sie einen Client wie oder der Die Erweiterung . symfony/lock predis/predis ext-redis composer require symfony/lock
# If using Redis
composer require predis/predis
# If using the new DynamoDB store (Symfony 7.4+)
composer require symfony/amazon-dynamo-db-lock
 Konfiguration in „Definieren Sie Ihre“ .” Ein häufiger Fehler ist die Verwendung eines einzigen Standard-Stores für alles. für verschiedene Geschäftsdomänen, um Kollisionen zu vermeiden und verschiedene Speicherstrategien zu ermöglichen (z. B. lokale Dateien für cron jobs vs. Redis für Benutzeraktionen). config/packages/lock.yaml lockers named lockers framework:
    lock:
        # Default store (good for single-server setups)
        enabled: true

        # Named lockers
        resources:
            # Critical business locks (Distributed)
            order_processing: '%env(REDIS_DSN)%'

            # CLI command locks (Local is usually fine)
            cron_jobs:
                - 'flock'

            # New in 7.4: DynamoDB for serverless architectures
            # This is commented out as it requires AWS credentials and the symfony/amazon-dynamo-db-lock package.
            # To use it, install the package and configure your AWS credentials.
            # invoice_generation:
            #     - 'dynamodb://default/lock_table'

            # For the attribute example, we'll just use redis.
            invoice_generation: '%env(REDIS_DSN)%'
 Die goldene Regel: Das Try-Finally-Muster Die einzige wichtigste Regel bei der Arbeit mit Schlössern besteht darin, sicherzustellen, dass sie freigegeben werden, auch wenn Ihr Code abstürzt.Während Symfony versucht, Schlösser bei Objektzerstörung automatisch freizugeben, sollten Sie sich niemals auf implizites Verhalten für kritische Ressourcen verlassen. Das Pattern Wickeln Sie Ihren kritischen Abschnitt immer in einen Versuchsblock und befreien Sie ihn schließlich. namespace App\Service;

use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\Component\Lock\LockFactory;

readonly class OrderProcessor
{
    public function __construct(
        #[Target('order_processing')]
        private LockFactory     $lockFactory,
        private LoggerInterface $logger,
    ) {}

    public function processOrder(int $orderId, bool $crash = false): void
    {
        // The resource name should be unique for each order.
        $lock = $this->lockFactory->createLock('order_' . $orderId, 30);

        $this->logger->info(sprintf('Attempting to acquire lock for order %d.', $orderId));

        if (!$lock->acquire()) {
            // Fail fast if another process is already handling this order.
            $this->logger->warning(sprintf('Order %d is already being processed.', $orderId));
            throw new \RuntimeException(sprintf('Order %d is already being processed.', $orderId));
        }

        $this->logger->info(sprintf('Lock acquired for order %d.', $orderId));

        try {
            // CRITICAL SECTION
            // This is where you would perform payment capture, inventory updates, etc.
            $this->logger->info(sprintf('Processing order %d. This will take a few seconds.', $orderId));
            sleep(5); // Simulate work

            if ($crash) {
                $this->logger->error(sprintf('Simulating a crash while processing order %d.', $orderId));
                throw new \Exception('Something went wrong! The payment gateway is down.');
            }

            $this->chargeUser($orderId);
            $this->logger->info(sprintf('Finished processing order %d.', $orderId));

        } finally {
            $this->logger->info(sprintf('Releasing lock for order %d.', $orderId));
            $lock->release();
        }
    }

    private function chargeUser(int $id): void
    {
        // In a real application, this would interact with a payment service.
        $this->logger->info(sprintf('Charging user for order %d.', $id));
        // ... payment logic
    }
}
 Um zu überprüfen, ob dies funktioniert, werfen Sie während der Entwicklung eine Ausnahme in den Versuchsblock. 
 
 
 
 Kaufen Sie das Lock. Geben Sie neue \Ausnahme(‘Crash!’) Überprüfen Sie Ihren Speicher (z.B. Redis KEYS *). Der Schlossschlüssel sollte sofort verschwunden sein, nachdem die Ausnahme vom Kernel erfasst oder aufgeblasen wurde. Der richtige Laden auswählen Die Wahl des falschen Shops ist ein häufiger architektonischer Fehler. +----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
| Store    | Use Case                             | Pros                                  | Cons                                                      |
+----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
| Flock    | Single-server cron jobs, local dev.  | Zero dependency, persistent on disk.  | Fails in Kubernetes/Docker Swarm (filesystems aren't shared). |
+----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
| Redis    | Distributed apps, user requests,     | Extremely fast, supports TTL.         | Requires Redis. Volatile (locks lost if Redis             |
|          | API limits.                          |                                       | crashes without AOF).                                     |
+----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
| Semaphore| Local high-performance IPC.          | Fastest for local processes.          | OS-dependent constraints. Hard to debug.                  |
+----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
| DynamoDB | Serverless / AWS Lambda environments.| Highly available, no server management.| Higher latency than Redis (network roundtrip).            |
+----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
 
 
 
 
 Gehen Sie lokal mit Flock oder Semaphore, wenn Sie auf einer einzigen Maschine laufen und maximale Geschwindigkeit mit minimalem Overhead benötigen. Go Verteilt mit Redis für die meisten modernen Webanwendungen, bei denen mehrere Knoten schnell koordinieren müssen. Gehen Sie Cloud-Native mit DynamoDB, wenn Sie in einer serverlosen Umgebung bauen, in der die Aufrechterhaltung einer dauerhaften Verbindung zu einem Cache wie Redis ineffizient ist. Wenn Sie Kubernetes verwenden, verwenden Sie niemals Flock oder Semaphore für Anwendungsebene-Locks. Declarative Locking mit Attributen In Symfony 7.4 + PHP 8.x können wir unsere Controller deutlich reinigen. in jedem Controller, können wir ein custom erstellen Dies ist ein "Senior Developer" -Muster, das Ihre Domain-Logik sauber hält. LockFactory #[Lock] Erstellen Sie das Attribut namespace App\Attribute;

use Attribute;

#[Attribute(Attribute::TARGET_METHOD)]
final class Lock
{
    public function __construct(
        public string $resourceName,
        public int $ttl = 30,
        public bool $blocking = false
    ) {}
}
 Erstellen des Event Listeners Wir verwenden die Kernel-Ereignisse, um das Lock zu erwerben, bevor der Controller es ausführt und danach freigibt. namespace App\EventListener;

use App\Attribute\Lock;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\HttpKernel\Event\ControllerEvent;
use Symfony\Component\HttpKernel\Event\TerminateEvent;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\Lock\LockFactory;
use Symfony\Component\Lock\LockInterface;
use Symfony\Component\HttpKernel\Exception\TooManyRequestsHttpException;
use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\Attribute\Target;

class LockAttributeListener
{
    private \WeakMap $locks;

    public function __construct(
        #[Target('invoice_generation')]
        private readonly LockFactory $lockFactory,
        private readonly LoggerInterface $logger,
    ) {
        $this->locks = new \WeakMap();
    }

    #[AsEventListener(event: KernelEvents::CONTROLLER)]
    public function onKernelController(ControllerEvent $event): void
    {
        $attributes = $event->getAttributes();
        if (!isset($attributes[Lock::class])) {
            return;
        }

        /** @var Lock $lockAttr */
        $lockAttr = $attributes[Lock::class][0];

        $request = $event->getRequest();
        $resource = $lockAttr->resourceName;

        // Simple interpolation for request attributes (e.g., 'invoice_{id}')
        foreach ($request->attributes->all() as $key => $value) {
            if (is_scalar($value)) {
                $resource = str_replace("{{$key}}", (string) $value, $resource);
            }
        }

        $this->logger->info(sprintf('Attempting to acquire lock for resource "%s".', $resource));

        $lock = $this->lockFactory->createLock($resource, $lockAttr->ttl);

        if (!$lock->acquire($lockAttr->blocking)) {
            $this->logger->warning(sprintf('Resource "%s" is currently locked.', $resource));
            throw new TooManyRequestsHttpException(null, 'Resource is currently locked.');
        }

        $this->logger->info(sprintf('Lock acquired for resource "%s".', $resource));

        // Store lock to release it later
        $this->locks[$event->getRequest()] = $lock;
    }

    #[AsEventListener(event: KernelEvents::TERMINATE)]
    public function onKernelTerminate(TerminateEvent $event): void
    {
        $request = $event->getRequest();
        if (isset($this->locks[$request])) {
            /** @var LockInterface $lock */
            $lock = $this->locks[$request];
            $resource = 'unknown'; // Can't easily get the resource name back from the lock object

            $this->logger->info(sprintf('Releasing lock for request to "%s".', $request->getPathInfo()));
            $lock->release();
            unset($this->locks[$request]);
        }
    }
}
 Verwenden Sie es in Ihrem Controller Jetzt ist Ihr Controller sauber, lesbar und sicher. namespace App\Controller;

use App\Attribute\Lock;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class InvoiceController extends AbstractController
{
    #[Route('/invoice/{id}/generate', name: 'invoice_generate')]
    #[Lock(resourceName: 'invoice_{id}', ttl: 60)]
    public function generate(int $id): Response
    {
        // This code executes ONLY if the lock is acquired
        // ... heavy generation logic ...
        
        return new Response('Invoice generated');
    }
 Verwalten von Langlaufaufgaben: Die Refresh() Methode Wenn Ihre Aufgabe 31 Sekunden dauert, aber Ihre Verschluss-TTL 30 Sekunden beträgt, läuft die Sperrung aus, wodurch ein weiterer Prozess gestartet werden kann und möglicherweise Daten beschädigt werden. Anstatt einen massiven TTL (z. B. 1 Stunde) einzustellen, der das System blockiert, wenn ein Absturz auftritt, verwenden Sie einen kürzeren TTL und erneuern Sie ihn. $lock = $factory->createLock('import_job', ttl: 30);
$lock->acquire(blocking: true);

try {
    foreach ($largeDataSet as $row) {
        $this->processRow($row);
        
        // Extend the lock by another 30 seconds
        $lock->refresh(); 
    }
} finally {
    $lock->release();
}
 Verification: 
 
 
 
 Setzen Sie einen TTL von 5 Sekunden ein. Führen Sie eine Schleife aus, die 2 Sekunden lang schläft und Refresh() ruft. Überwachen Sie die Ablaufzeit in Ihrem Shop (z. B. Redis TTL lock_key). Sie sollten sehen, dass es wiederholt auf 30 s zurückgeht, niemals auf 0 fällt. Blockieren vs. Nicht blockieren Mit dem Default, ist nicht blockierend. Es kehrt falsch sofort zurück, wenn die Ressource beschäftigt ist. Pass true auf unbestimmte Zeit zu warten: acquire() // Wait forever until lock is free
$lock->acquire(true);
 Vermeiden Sie unbefristete Blockierungen in HTTP-Anfragen. Es verbindet Ihre PHP-FPM-Arbeiter und kann zu einem 504 Gateway Timeout führen. Verwenden Sie eine Schleife mit einem Timeout für eine bessere Kontrolle: Best Practice: $maxRetries = 5;
$retryCount = 0;

while (!$lock->acquire()) {
    if ($retryCount++ >= $maxRetries) {
        throw new \Exception('Could not acquire lock after 5 attempts');
    }
    sleep(1); // Wait 1 second before retrying
}
 Schlussfolgerungen Verwenden der In Symfony 7.4 geht es nicht nur darum, Dateien zu „verschließen“, sondern auch um architektonische Absichten. symfony/lock 
 
 
 
 
 Immer Named Lockers verwenden: Trennen Sie Ihre Lock Stores nach Domain (Order, cron, Benutzer). Remote Stores bevorzugen: Verwenden Sie Redis oder DynamoDB für jede Anwendung, die auf mehr als einem Server ausgeführt wird. Clean Code: Nehmen Sie das Attribute-Muster an, um Boilerplate von Ihren Controllern zu entfernen. Sicherheit Erstens: Der Test-Finally-Block ist nicht verhandelbar. Konkurrenz-Bugs sind notorisch schwer zu reproduzieren. Die Implementierung dieser Muster heute spart Ihnen Stunden von Debugging morgen. Sie können die vollständige Implementierung finden und den Fortschritt des Projekts auf GitHub verfolgen: [ ] Source Code: https://github.com/mattleads/SymfonyLockSample https://github.com/mattleads/SymfonyLockSample Lassen Sie uns verbinden! Wenn Sie dies hilfreich fanden oder Fragen zur Implementierung haben, würde ich gerne von Ihnen hören. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] X (Twitter): [https://x.com/MattLeads] Nachrichten: [https://t.me/MattLeads] GitHub: [https://github.com/mattleads] https://www.linkedin.com/in/matthew-mochalkin/ https://x.com/MattLeads https://t.me/MattLeads https://github.com/mattleads

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Read My Stories

Dieses Audio ist in der Originalsprache der Geschichte produziert!

Wie man Konkurrenz beherrscht: Best Practices für Symfony 7.4 Lock-Komponente

About Author

KOMMENTARE

Hängeetiketten

DIESER ARTIKEL WURDE VORGESTELLT IN

Related Stories

HackerNoon Decoded 2024: Wir feiern unsere Gaming-Community!

Meet Deepgram: HackerNoon Company of the Week

HackerNoon Decoded 2024: Celebrating Our Data Science Community!

HackerNoon Decoded 2024: Celebrating Our Startups Community!

HackerNoon Decoded 2024: Wir feiern unsere Gaming-Community!

Meet Deepgram: HackerNoon Company of the Week

HackerNoon Decoded 2024: Celebrating Our Data Science Community!

HackerNoon Decoded 2024: Celebrating Our Startups Community!

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps