Laravel's queue priority is controlled through the startup sequence. The specific steps are: 1. Define multiple queues in the configuration file; 2. Specify the queue priority when starting a worker, such as php artisan queue:work --queue=high,default; 3. Use the onQueue() method to specify the queue name when distributing tasks; 4. Use Laravel Horizon and other tools to monitor and manage queue performance. This ensures that high-priority tasks are processed first while maintaining code maintainability and system stability.

Laravel's queue system is powerful, and when you start dealing with multiple types of jobs that need different levels of urgency, setting up queue priorities become a practical necessity. It's not just about getting things done — it's about getting the right things done first.

Understanding Queue Priorities in Laravel

In Laravel, queues are processed by workers, and each worker listens to one or more queues. By default, a worker processes jobs in the order they're added — FIFO (first-in, first-out). But if some jobs are time-sensitive or more critical than others, you can assign them to a separate, higher-priority queue.

For example, imagine your app sends email notifications and also runs nightly data syncs. You'd want the emails to go out quickly, while the data sync can wait. In this case, you might have two queues: high for emails and default for the syncs.

To define multiple queues, update your queue.php config file:

 'default' => env('QUEUE_CONNECTION', 'redis'),
'connections' => [
    'redis' => [
        'driver' => 'redis',
        'connection' => 'default',
        'queue' => 'default',
        'retry_after' => 90,
    ],
],

But here's the catch — the actual priority behavior comes from how you run the queue workers.

Running Workers with Priority Order

The key to queue prioritization lies in how you launch your queue workers. Laravel doesn't enforce a built-in priority system; instead, you control it by starting workers that listen to queues in a specific order.

Here's how you do it:

• Start a worker that listens to the high-priority queue first , then falls back to lower ones:

   php artisan queue:work --queue=high,default

This tells Laravel to check the high queue first. If there's a job waiting, process it immediately. If not, it moves on to the default queue.

You can chain as many queues as you need:

 php artisan queue:work --queue=urgent,high,medium,default

The order matters. Laravel will always check the first queue in the list before moving on. This gives you a simple but effective way to prioritize work without complex logic.

A common mistake is assuming that all queues are processed simultaneously. They're not — they're checked sequentially.

Dispatching Jobs to the Right Queue

Once you've set up your queue priorities, you need to make sure jobs actually land in the correct queue. When dispatching a job, specify the queue name like this:

 dispatch((new SendEmailJob($user))->onQueue('high'));

Or, using the helper function:

 SendEmailJob::dispatch($user)->onQueue('high');

If you're using Laravel's job batching feature, you can also assign the whole batch to a specific queue:

 Bus::batch([$job1, $job2])->onQueue('medium')->dispatch();

Make sure your naming convention is consistent. Use describe names like high , background , or critical so anyone reading the code later understands the intent.

Also, double-check that the queue name used in both the dispatch and the worker command match exactly — a typo can send jobs into oblivion.

Monitoring and Managing Queue Performance

Even with priorities in place, you should monitor how each queue behaves over time. Tools like Laravel Horizon (for Redis) or database-based monitoring can help track queue depths, failure rates, and processing times.

A few quick tips for managing performance:

• Use Laravel Horizon to see real-time stats for each queue.
• Set timeouts and retries appropriately based on job type.
• Consider scaling workers dynamically — more workers for high-priority queues during peak hours.
• Don't forget to clean up failed jobs regularly.

One thing to keep in mind: even if a queue is marked as "high" priority, if it's constantly backed up, you may need to scale up the number of workers handling it. Priority alone won't solve throughput issues.

That's basically how you configure and use queue priorities in Laravel. It's straightforward once you understand how the queue worker handles queue order and how to route jobs correctly. Not rocket science, but easy to mess up if you overlook small details like naming or execution order.

The above is the detailed content of Configuring and Using Queue Priorities in Laravel. For more information, please follow other related articles on the PHP Chinese website!