Në aplikacionet me konkurrencë të lartë, kushtet e garës janë vrasësit e heshtur të integritetit të të dhënave. Pavarësisht nëse parandalon dyfishimin e rezervimeve në një sistem rezervimi, siguron që një punë cron të funksionojë vetëm në një server, ose pengon përdorimin e API-ve, Është linja juaj e parë e mbrojtjes. Symfony Lock Component Me lirimin e , ekosistemi është pjekur, duke ofruar atribute më të pastra, integrim më të mirë me dyqanet cloud-native (si Ky artikull mbulon praktikat më të mira të testuara në betejë që unë përdor në prodhim, duke siguruar që aplikacioni juaj mbetet i fuqishëm dhe pa deadlock. Symfony 7.4 DynamoDB Instalimi dhe Konfigurimi Filloni duke instaluar komponentin. ne do të përdorim standardin Nëse planifikoni të përdorni Redis (e rekomanduar për sisteme të shpërndara), sigurohuni që të keni një klient si Ose të zgjerimin e 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
 Konfigurimi në Përcaktoni “Të .” Një gabim i zakonshëm është përdorimi i një dyqani të vetëm default për gjithçka. për domene të ndryshme të biznesit për të shmangur përplasje dhe për të lejuar strategji të ndryshme të ruajtjes (p.sh., skedarë lokalë për punët cron vs. Redis për veprimet e përdoruesit). 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)%'
 Rregulli i Artë: Modeli i Try-Finally Rregulli më i rëndësishëm kur punoni me blloqet është që të siguroheni që ato të lëshohen, edhe nëse kodi juaj rrëzohet.Ndërsa Symfony përpiqet të lëshojë automatikisht blloqet në shkatërrimin e objektit, ju kurrë nuk duhet të mbështeteni në sjelljen e nënkuptuar për burimet kritike. Patternë Gjithmonë mbështillni seksionin tuaj kritik në një bllok të provës dhe lironi në fund. 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
    }
}
 Për të verifikuar këtë funksionon, hedh një përjashtim brenda bllokut të provës gjatë zhvillimit. 
 
 
 
 Merrni një mbyllje. Throw new \Përjashtim (‘Crash!’) Kontrolloni ruajtjen tuaj (p.sh., Redis KEYS *). çelësi i kyçjes duhet të jetë zhdukur menjëherë pasi përjashtimi është kapur nga kerneli ose flluska. Zgjedhja e dyqanit të duhur Zgjedhja e dyqanit të gabuar është një gabim i zakonshëm arkitektonik. +----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
| 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).            |
+----------+--------------------------------------+---------------------------------------+-----------------------------------------------------------+
 
 
 
 
 Shko Lokale me Flock ose Semaphore nëse jeni duke punuar në një makinë të vetme dhe keni nevojë për shpejtësi maksimale me një minimum të mbivendosjes. Shko Distributed me Redis për shumicën e aplikacioneve moderne të internetit, ku shumë nyje duhet të koordinohen shpejt. Shkoni Cloud-Native me DynamoDB nëse jeni duke ndërtuar në një mjedis pa server ku mbajtja e një lidhjeje të vazhdueshme me një cache si Redis është e paefektshme. Nëse jeni duke punuar në Kubernetes, kurrë mos përdorni Flock ose Semaphore për blloqet e nivelit të aplikacionit. Gjithmonë përdorni Redis, Memcached ose databazat (PDO/DynamoDB). Locking Deklarative me atribute Në Symfony 7.4 + PHP 8.x, ne mund të pastrojmë kontrolluesit tanë në mënyrë të konsiderueshme. në çdo kontrollues, ne mund të krijojmë një custom Ky është një model "Zhvillues i lartë" që mban logjikën e domain tuaj të pastër. LockFactory #[Lock] Krijimi i një atributi 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
    ) {}
}
 Krijimi i dëgjimit të ngjarjes Ne përdorim ngjarjet e bërthamës për të fituar bllokun para se kontrolli të ekzekutojë dhe ta lëshojë atë më pas. 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]);
        }
    }
}
 Përdoreni atë në kontrolluesin tuaj Tani, kontrolli juaj është i pastër, i lexueshëm dhe i sigurt. 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');
    }
 Menaxhimi i detyrave të gjata: Metoda refresh() Një kurth i zakonshëm është vendosja e një TTL (Time To Live) që është shumë i shkurtër për detyrën.Nëse detyra juaj merr 31 sekonda, por TTL-ja juaj e bllokimit është 30 sekonda, ky bllokim do të përfundojë, duke lejuar një proces tjetër për të filluar, duke dëmtuar potencialisht të dhënat. Në vend që të vendosni një TTL masive (p.sh., 1 orë), e cila bllokon sistemin nëse ndodh një kolaps, përdorni një TTL më të shkurtër dhe rifreskoje atë. $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: 
 
 
 
 Vendosni një TTL prej 5 sekondash. Run një cikël që fle për 2 sekonda dhe thërret refresh(). Monitoroni kohën e skadimit në dyqanin tuaj (p.sh., Redis TTL lock_key). Ju duhet të shihni se ajo rivendoset në 30s në mënyrë të përsëritur, kurrë nuk bie në 0. Bllokim vs. jo bllokim Për shkak të defektit, është jo-blocking. Ajo kthehet false menjëherë në qoftë se burimi është i zënë. kaloni të vërtetë për të pritur pafundësisht: acquire() // Wait forever until lock is free
$lock->acquire(true);
 Shmangni bllokimin e pafund në kërkesat HTTP. Ajo lidh punonjësit tuaj PHP-FPM dhe mund të çojë në një 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
}
 Konkludimet Përdorimi i Komponenti nuk ka të bëjë vetëm me "mbylljen" e skedarëve; ka të bëjë me qëllimin arkitektonik. symfony/lock 
 
 
 
 
 Gjithmonë përdorni Named Lockers: Ndarni dyqanet tuaja të bllokimit sipas domain (order, cron, user). Preferoni dyqanet e largëta: Përdorni Redis ose DynamoDB për çdo aplikacion që punon në më shumë se një server. Kodi i pastër: Përdorni modelin Attribute për të hequr boilerplate nga kontrolluesit tuaj. Siguria e parë: Blloku i provës së fundit nuk është i negociueshëm. Gabimet e konkurrencës janë të vështira për t'u riprodhuar.Zbatimi i këtyre modeleve sot do t'ju kursejë orë debugging nesër. Ju mund të gjeni implementimin e plotë dhe të ndiqni progresin e projektit në GitHub: [ ] Source Code: https://github.com/mattleads/SymfonyLockSample https://github.com/mattleads/SymfonyLockSample Le të lidhemi! Nëse e keni gjetur këtë të dobishme ose keni pyetje në lidhje me zbatimin, do të doja të dëgjoja nga ju. 
 
 
 
 
 LinkedIn: [https://www.linkedin.com/in/matthew-mochalkin/] X (Twitter): [https://x.com/MattLeads] Shërbimi: [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

Kjo audio është prodhuar në gjuhën origjinale të tregimit!

Si të menaxhoni konkurrencën: Praktikat më të mira për komponentin e bllokimit të Symfony 7.4

About Author

KOMENTE

VARUR TAGS

KY ARTIKU U PARAQIT NË

Related Stories

Rrjeti SQD sapo vrau emetimet e tokenëve.Ja çfarë paguan 16 miliardë dollarë në DeFi TVL

Rrjeti SQD sapo vrau emetimet e tokenëve.Ja çfarë paguan 16 miliardë dollarë në DeFi TVL

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps