Laravel queues are an essential feature for any developer looking to optimize their application’s performance and user experience. By offloading time-consuming tasks to the background, queues allow your app to respond to users quickly while processing jobs asynchronously. In this article, we’ll break down the main concepts you need to understand about Laravel queues, illustrated with two practical examples: sending email notifications and generating PDF invoices. Whether you’re new to queues or want a clear overview of how to implement and manage them effectively, this guide will cover everything from basic usage to handling failures and setting up queues in production environments.
Why Use Queues in Laravel?
Imagine you have an application where users perform actions that trigger time-intensive processes, such as sending emails, generating reports, or processing uploaded files. Without queues, the user has to wait for these tasks to complete before receiving any feedback. This leads to poor user experience, especially if multiple notifications or reports are involved.
Queues solve this by moving these long-running tasks into the background. Your application can immediately respond with a success message, while the queued jobs execute asynchronously. This approach keeps your app fast and responsive, even under heavy load.
Example 1: Queuing Email Notifications
Let’s start with a common use case: sending email notifications. Suppose you create a new task in your app and need to notify several users assigned to it. Sending emails to multiple recipients can take several seconds, causing the user to wait unnecessarily.
Here’s what happens without queues:
- The task is created.
- The notification emails are sent synchronously.
- The user waits until all emails are dispatched.
Testing this, sending notifications to three users took roughly 4 seconds, which would only increase with more users. This scenario is a perfect example where Laravel queues shine.
Making Notifications Queueable
Laravel makes it very easy to queue notifications. In fact, notification classes are queueable by default. To enable queuing, your notification class needs to implement the ShouldQueue interface and use the Queueable trait:
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Bus\Queueable;
class TaskAssignedNotification extends Notification implements ShouldQueue
{
use Queueable;
// Notification code ...
}
Once this is done, sending notifications dispatches jobs to the queue instead of sending emails immediately.
Queue Driver and Processing Jobs
By default, Laravel uses the database queue driver, which stores queued jobs in a database table named jobs. For every notification email, a job record is created in the table awaiting processing.
To process queued jobs, you run the following Artisan command:
php artisan queue:work
This command starts a queue worker that listens for new jobs and processes them one by one. When running the queue worker in the background, your app can quickly respond to user actions while processing jobs asynchronously.
Experience with Queued Notifications
With queues enabled, sending notifications to multiple users becomes almost instant from the user’s perspective. The success message appears immediately, and emails are sent shortly thereafter in the background.
This not only improves user experience but also scales better when you need to notify many users simultaneously.
Example 2: Queuing PDF Invoice Generation
Queues are not limited to notifications. You can queue any time-consuming process, such as generating a PDF invoice for an order. Generating PDFs often takes a few seconds, which is a poor experience if done synchronously.
Creating a Custom Queue Job
To queue PDF generation, you create a custom job using Artisan:
php artisan make:job GenerateOrderInvoice
This job class implements ShouldQueue and uses the Queueable trait. Inside the handle method, you write the logic to build the PDF from a Blade view:
public function handle()
{
$order = Order::find($this->orderId);
$pdf = PDF::loadView('invoices.order', compact('order'));
// Save or email the PDF...
}
The job receives the order ID as a parameter, which you can pass when dispatching the job from the controller:
GenerateOrderInvoice::dispatch($order->id);
Pro Tip: Re-query Data Inside the Job
Since jobs may be processed with some delay, it’s a good practice to re-query the database inside the job to get the latest data. This ensures that the PDF invoice reflects the most current order information.
Sending the PDF Immediately
Within the same job, you can also trigger notifications or emails to send the generated PDF to the customer, making the entire process seamless and efficient.
Handling Queue Job Failures
What happens if a queued job fails? For example, a typo in the code or a database error could cause the job to crash. Understanding failure handling is crucial for robust queue management.
Failure Behavior with Database Driver
When a job fails, it is removed from the jobs table and recorded in the failed_jobs table, along with the error message and stack trace. The Laravel log file (laravel.log) also captures the error details.
To simulate failure, you can introduce an error in your job code and observe the job’s failure handling.
Retrying Failed Jobs
After fixing the issue that caused failure, you must restart the queue worker for it to pick up the new code. This is because the queue worker loads your Laravel application only once when it starts and does not automatically reload changes.
You can retry failed jobs with the following Artisan command:
php artisan queue:retry all
This moves failed jobs back to the main jobs queue to be processed again.
Job Retry Parameters
Laravel allows you to specify job-specific parameters such as maximum retry attempts, timeout durations, and backoff delays. These settings help control how jobs behave on failure and can be configured directly in your job classes.
Queue Drivers and Production Setup
While the database driver is convenient for local development, production environments usually require more robust queue drivers. Laravel supports several drivers, with Redis being the most popular choice for live servers.
Using Redis for Queues
Redis is an in-memory data structure store that provides fast queue management capabilities. Setting up Redis involves installing Redis on your server and configuring Laravel to use it as the queue connection.
Monitoring Queues with Laravel Horizon
Laravel Horizon is a powerful dashboard specifically designed to monitor Redis queues. It provides insights into job throughput, runtime, failures, and more, making it an indispensable tool for production queue management.
Horizon also offers commands to gracefully restart queue workers, such as:
php artisan horizon:terminate
This ensures all workers reload the latest code without manual intervention.
Supervisor for Process Management
Queue workers are long-running processes that can crash unexpectedly. To keep them running reliably, you should use a process control system like Supervisor. Supervisor automatically restarts queue workers if they fail and ensures continuous job processing.
The Laravel documentation provides a detailed section on configuring Supervisor for queue workers.
Simplifying Production Setup
Setting up Redis, Horizon, and Supervisor can be complex. Tools like Laravel Forge simplify this by automating the installation and configuration of Redis, queue workers, and Supervisor with just a few clicks.
Other services like Laravel Cloud or deployment tools like Ploy also help manage queue infrastructure more easily.
Best Practices and Further Learning
Queues open up a whole new dimension of application optimization. Beyond the basics, managing queues effectively involves:
- Monitoring queue performance and job status
- Scaling workers horizontally across multiple servers
- Handling long-running jobs with timeouts and retries
- Implementing batch jobs and job chaining
Conclusion
Laravel queues are a powerful tool to improve your application’s responsiveness and scalability by offloading time-consuming tasks to the background. Whether it’s sending email notifications or generating PDF invoices, queues let your users get instant feedback while jobs process asynchronously.
Understanding how to implement queueable notifications and custom jobs, handle failures, and set up queues properly in production is essential for any Laravel developer. With the right tools like Redis, Laravel Horizon, and Supervisor, you can build robust queue systems that keep your applications running smoothly at scale.
If you want to get started quickly, explore the code repository linked below and try out the examples yourself. For ongoing learning, consider the Laravel Daily courses that cover queues extensively.
Helpful Links:
