使用 Symfony Lock 组件有效管理并发请求与防止数据重复

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Lock\LockFactory;
use Symfony\Component\Routing\Annotation\Route;

class LockTestController extends AbstractController
{
    #[Route("/test-blocking")]
    public function testBlocking(LockFactory $factory): JsonResponse
    {
        // 创建一个名为 "my_resource_lock" 的锁
        $lock = $factory->createLock("my_resource_lock");

        $startTime = microtime(true);
        // 尝试阻塞式获取锁，如果锁被占用，会等待
        $acquired = $lock->acquire(true); // true 是默认值，可以省略

        $acquireTime = microtime(true) - $startTime;

        // 模拟耗时操作
        sleep(2);

        // 锁会在方法结束时自动释放，但也可以手动调用 $lock->release();

        return new JsonResponse([
            "acquired" => $acquired,
            "acquireTime" => round($acquireTime, 4),
            "message" => "Lock acquired and released (blocking)"
        ]);
    }

    #[Route("/test-non-blocking")]
    public function testNonBlocking(LockFactory $factory): JsonResponse
    {
        $lock = $factory->createLock("my_resource_lock");

        $startTime = microtime(true);
        // 尝试非阻塞式获取锁，如果锁被占用，立即返回 false
        $acquired = $lock->acquire(false);

        $acquireTime = microtime(true) - $startTime;

        if (!$acquired) {
            return new JsonResponse([
                "acquired" => false,
                "acquireTime" => round($acquireTime, 4),
                "message" => "Lock could not be acquired (non-blocking)",
            ], JsonResponse::HTTP_TOO_MANY_REQUESTS); // 429 Too Many Requests
        }

        // 模拟耗时操作
        sleep(2);

        // 锁会在方法结束时自动释放
        return new JsonResponse([
            "acquired" => true,
            "acquireTime" => round($acquireTime, 4),
            "message" => "Lock acquired and released (non-blocking)"
        ]);
    }
}

curl -k 'https://localhost/test-blocking' & curl -k 'https://localhost/test-blocking'

{"acquired":true,"acquireTime":0.0007,"message":"Lock acquired and released (blocking)"}
{"acquired":true,"acquireTime":2.0871,"message":"Lock acquired and released (blocking)"}

curl -k 'https://localhost/test-non-blocking' & curl -k 'https://localhost/test-non-blocking'

{"acquired":true,"acquireTime":0.0008,"message":"Lock acquired and released (non-blocking)"}
{"acquired":false,"acquireTime":0.0005,"message":"Lock could not be acquired (non-blocking)"}

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Lock\LockFactory;
use Symfony\Component\Routing\Annotation\Route;

class EntityCreationController extends AbstractController
{
    #[Route("/create-entity", methods: ["POST"])]
    public function createEntity(LockFactory $factory): JsonResponse
    {
        // 为创建实体操作创建一个锁，例如基于用户ID或特定资源ID
        // 这里的 "create_entity_lock" 是一个通用的锁名，实际应用中应更具体
        $lock = $factory->createLock("create_entity_lock", 10); // 设置10秒TTL

        // 尝试非阻塞式获取锁
        if (!$lock->acquire(false)) {
            // 如果锁已被占用，说明有其他请求正在处理，立即拒绝
            return new JsonResponse([
                "status" => "error",
                "message" => "请求正在处理中，请勿重复提交。"
            ], JsonResponse::HTTP_TOO_MANY_REQUESTS); // HTTP 429
        }

        try {
            // 模拟耗时的实体创建逻辑
            sleep(3); // 假设数据库操作和业务逻辑需要3秒
            // ... 在这里执行实际的实体创建和数据库持久化操作 ...

            // 成功创建实体后，返回成功响应
            return new JsonResponse([
                "status" => "success",
                "message" => "实体已成功创建。"
            ]);
        } finally {
            // 确保在任何情况下锁都能被释放
            // 锁通常在请求结束时自动释放，但明确释放是一个好习惯
            // 尤其是在 try-finally 块中，可以确保即使有异常也能释放
            $lock->release();
        }
    }
}

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Symfony\Component\Lock\LockFactory;
use Symfony\Component\Routing\Annotation\Route;

class ExportController extends AbstractController
{
    #[Route("/export-data")]
    public function export(LockFactory $factory): Response
    {
        // 创建一个锁，并设置一个较长的 TTL，例如 60 秒
        $lock = $factory->createLock("data_export_lock", 60);

        // 尝试非阻塞式获取锁，防止多个导出请求同时进行
        if (!$lock->acquire(false)) {
            return new Response("导出任务正在进行中，请稍后再试。", Response::HTTP_TOO_MANY_REQUESTS);
        }

        $response = new StreamedResponse(function () use ($lock) {
            // 此时 $lock 实例在闭包中仍然存活

            // 记录上次刷新锁的时间
            $lastLockRefreshTime = time();
            $refreshInterval = 50; // 每50秒刷新一次锁，略小于锁的TTL (60秒)

            // 模拟数据生成和输出
            for ($i = 0; $i < 10; $i++) {
                // 模拟每次输出一些数据需要的时间
                sleep(5);
                echo "Line " . ($i + 1) . " of exported data\n";
                ob_flush(); // 刷新输出缓冲区
                flush();    // 刷新系统缓冲区

                // 检查是否需要刷新锁
                if (time() - $lastLockRefreshTime > $refreshInterval) {
                    $lock->refresh(); // 刷新锁，延长其生命周期
                    $lastLockRefreshTime = time();
                    // error_log("Lock refreshed at " . date('H:i:s')); // 可用于调试
                }
            }
            // 所有数据输出完毕后，手动释放锁
            $lock->release();
        });

        $response->headers->set('Content-Type', 'text/plain'); // 或 'text/csv'
        $response->headers->set('Content-Disposition', 'attachment; filename="export.txt"');

        // 如果没有将 $lock 传递给闭包，锁会在此时被释放
        return $response;
    }
}