如何通过Supervisor实现Laravel队列任务的顺序执行？

Hey there! The issue you're facing is totally expected because Laravel's queue workers run in parallel by default (especially when Supervisor is configured with multiple processes). To make your SavePRJob tasks execute sequentially (one after another), here are a few solid solutions tailored to your scenario:

This is the most straightforward way to enforce strict sequential execution, as we'll isolate these PR processing tasks to their own queue and only run one worker for it.

Step 1: Update your job dispatch to target a specific queue #

Modify your controller code to send the job to a dedicated queue (let's call it pr-processing):

public function demoPR(Request $request) {
    // ...
    SavePRJob::dispatch($request->all(), $data)->onQueue('pr-processing');
}

Step 2: Configure Supervisor for this single-worker queue #

Update your Supervisor configuration (usually in /etc/supervisor/conf.d/laravel-worker.conf) to add a separate worker for the pr-processing queue with only 1 process:

[program:laravel-pr-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /path-to-your-project/artisan queue:work --queue=pr-processing --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
user=your-user-name
numprocs=1 ; This ensures only one worker runs for this queue
redirect_stderr=true
stdout_logfile=/path-to-your-project/storage/logs/pr-worker.log

After updating, reload Supervisor to apply changes:

sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start laravel-pr-worker:*

Pros: Strict FIFO (first-in-first-out) execution, tasks run exactly in the order they were queued.
Cons: The dedicated worker can only handle these PR tasks, so if you have a backlog, other queue tasks won't be affected, but this worker will be occupied until all PR tasks are done.

If you don't want to manage a separate Supervisor process, you can use Laravel's built-in middleware to prevent multiple instances of SavePRJob from running at the same time. This uses a cache lock to ensure only one instance executes at a time.

Step 1: Add the middleware to your SavePRJob class #

Modify your job class to include the middleware:

use Illuminate\Queue\Middleware\WithoutOverlapping;

class SavePRJob implements ShouldQueue {
    private $inputs;
    private $data;

    // Add this method
    public function middleware()
    {
        // Use a unique lock name to group all PR processing tasks
        return [new WithoutOverlapping('pr-processing-lock')];
    }

    public function __construct($inputs, $data) {
        $this->inputs = $inputs;
        $this->data = $data;
    }

    // ... rest of your handle() method
}

Notes: #

• This requires your cache driver to support atomic locks (Redis, Memcached work great; database cache is not recommended for this).
• If a new SavePRJob is queued while another is running, the new job will be released back to the queue and retried after a default delay (you can customize this with ->releaseAfter(seconds) in the middleware).

Pros: No changes needed to Supervisor, works with your existing queue setup.
Cons: Tasks might not execute in strict FIFO order if retries are involved (though in most cases, they will still follow the general queue order).

内容的提问来源于stack exchange，提问作者Kalpashree V. Bal