U visoko konkurentnim aplikacijama, uvjeti utrke su tihi ubojice integriteta podataka. Bilo da se radi o sprečavanju dvostrukih rezervacija u sistemu rezervacija, osiguravanju da cron posao radi na samo jednom serveru ili ograničavanju upotrebe API-ja, To je vaša prva linija odbrane. Symfony Lock Component Uz oslobađanje od , ekosustav je sazreo, nudeći čistije atribute, bolju integraciju sa skladištima u oblaku (kao što su Ovaj članak pokriva borbeno testirane najbolje prakse koje koristim u proizvodnji, osiguravajući da vaša aplikacija ostaje robusna i bez zastoja. Symfony 7.4 DynamoDB Ugradnja i konfiguracija Počnite instaliranjem komponente. Koristićemo standardni Ako planirate da koristite Redis (preporučuje se za distribuirane sisteme), pobrinite se da imate klijent kao što je ili na Proširenje 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
 Konfiguracija U Definišite svoj » .” Uobičajena greška je korištenje jedne podrazumevane trgovine za sve. za različite poslovne domene kako bi se izbjegao sudar i omogućile različite strategije skladištenja (npr. lokalne datoteke za cron jobs vs. Redis za korisničke akcije). 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)%'
 Zlatno pravilo: Način na koji pokušavate konačno Jedino najvažnije pravilo kada se radi o zaključcima je da se osigura da su oni pušteni, čak i ako se vaš kod sruši. Dok Symfony pokušava automatski puštati zaključake na uništenje objekata, nikada se ne biste trebali oslanjati na implicitno ponašanje za kritične resurse. Uzorci Uvek zavijte vašu kritičnu sekciju u pokušaj blok i oslobodite se konačno. 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
    }
}
 Da biste provjerili da to radi, bacite izuzetak unutar pokušaja blok tijekom razvoja. 
 
 
 
 Kupite ključ. Bacite novi \Izuzetak (‘Crash!’) Provjerite svoje skladištenje (npr. Redis KEYS *). ključ za zaključavanje trebao bi biti nestao odmah nakon što je izuzetak uhvaćen od strane jezgre ili bubuljica. Odabir prave trgovine Odabir pogrešne prodavnice je uobičajeni arhitektonski nedostatak. +----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
| 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).            |
+----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
 
 
 
 
 Idite lokalno sa Flock ili Semaphore ako radite na jednoj mašini i trebate maksimalnu brzinu s minimalnim prekomjernim radom. Idite Distributed sa Redis za većinu modernih web aplikacija, gde više čvorova treba brzo koordinirati. Idite Cloud-Native sa DynamoDB-om ako gradite u okruženju bez servera u kojem je održavanje trajne povezanosti sa kešem kao što je Redis neučinkovito. Ako koristite Kubernetes, nikada ne koristite Flock ili Semaphore za zaključavanje na razini aplikacije. Uvek koristite Redis, Memcached ili skladišta baze podataka (PDO/DynamoDB). Deklarativno zaključavanje sa atributima U Symfony 7.4 + PHP 8.x, možemo značajno očistiti naše kontrolere. Umjesto ubrizgavanja u svakom kontroloru, možemo stvoriti naviku To je "Senior Developer" uzorak koji održava vašu logiku domena čistim. LockFactory #[Lock] Stvaranje atributa 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
    ) {}
}
 Stvaranje slušalice događaja Koristimo nuklearne događaje za stjecanje zaključaka pre nego što kontroler izvrši i oslobodi ga kasnije. 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]);
        }
    }
}
 Koristite ga u svom kontroleru Sada je vaš kontroler čist, čitljiv i siguran. 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');
    }
 Rješavanje dugotrajnih zadataka: metoda refresh() Ako vaš zadatak traje 31 sekundu, ali vaš TTL za zaključavanje je 30 sekundi, zaključavanje će isteći, dopuštajući drugom procesu da počne, potencijalno oštećujući podatke. Umesto postavljanja masivnog TTL (npr. 1 sat), koji blokira sistem ako dođe do nesreće, koristite kraći TTL i osvežite ga. $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: 
 
 
 
 Postavite TTL od 5 sekundi. Pokrenite krug koji spava 2 sekunde i zove osvježenje (). Praćenje vremena isteka u vašoj prodavnici (npr. Redis TTL lock_key). Trebalo bi da vidite da se ponavlja na 30s više puta, nikada ne pada na 0. Blokiranje vs. ne blokiranje U slučaju defaulta, je ne-blokirajući. Vraća lažno odmah ako je resurs zauzet. Proći istina da sačeka beskrajno: acquire() // Wait forever until lock is free
$lock->acquire(true);
 Izbjegavajte neograničeno blokiranje u HTTP zahtjevima. To povezuje vaše PHP-FPM radnike i može dovesti do 504 Gateway Timeout. 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
}
 Zaključci Koristeći komponenta nije samo o "zaključivanju" datoteka; to je o arhitektonskoj namjeri. symfony/lock 
 
 
 
 
 Uvek koristite imenovane zaključivače: odvojite svoje zaključivačke trgovine po domenama (porudžbina, cron, korisnik). Preferirajte daljinske trgovine: Koristite Redis ili DynamoDB za bilo koju aplikaciju koja se pokreće na više od jednog servera. Čista Koda: Usvojite uzorak atributa da biste uklonili boilerplate iz kontrolera. Sigurnost Prvo: Pokušaj-finalni blok nije pregovarački. Implementacija ovih uzoraka danas će vam uštedjeti sati debugiranja sutra. Možete pronaći punu implementaciju i pratiti napredak projekta na GitHubu: [ ] Source Code: https://github.com/mattleads/SymfonyLockSample https://github.com/mattleads/SymfonyLockSample Hajde da se povežemo! Ako ste ovo pronašli korisno ili imate pitanja o implementaciji, rado bih čuo od vas. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Uslovi korišćenja: [https://x.com/MattLeads] Uslovi korišćenja: [https://t.me/MattLeads] Uslovi korišćenja: [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

Ovaj audio je proizveden na originalnom jeziku priče!

Kako upravljati konkurencijom: najbolje prakse za Symfony 7.4 zaključavanje komponenta

About Author

KOMENTARI

HANG TAGS

OVAJ ČLANAK JE PREDSTAVLJEN U

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps