PHPackages                             kode/queue - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Database & ORM](/categories/database)
4. /
5. kode/queue

ActiveLibrary[Database & ORM](/categories/database)

kode/queue
==========

一个现代化、高性能的 PHP 队列客户端，支持多种队列驱动，专为 PHP 8.1+ 设计，完美支持 PHP 8.5 管道操作符新特性

1.4.0(2mo ago)12Apache-2.0PHPPHP >=8.1

Since Mar 18Pushed 2mo agoCompare

[ Source](https://github.com/kodephp/queue)[ Packagist](https://packagist.org/packages/kode/queue)[ Docs](https://github.com/kodephp/queue)[ RSS](/packages/kode-queue/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (1)Versions (2)Used By (0)

Kode\\Queue
===========

[](#kodequeue)

一个现代化、高性能的 PHP 队列客户端，支持多种队列驱动，专为 PHP 8.1+ 设计，完美支持 PHP 8.5 管道操作符新特性。

[![PHP Version](https://camo.githubusercontent.com/fabeba9a1fce5ab2d034002842f688c3a48beacc3845d75e287216c7c38e37e2/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5048502d253345253344382e312d383839324246)](https://php.net)[![License](https://camo.githubusercontent.com/54a591a708d9e41adc220d00e0caa979b5a5c035327d4eebaab67748cc889e4a/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d4170616368652d2d322e302d677265656e)](LICENSE)

目录
--

[](#目录)

- [特性](#%E7%89%B9%E6%80%A7)
- [安装](#%E5%AE%89%E8%A3%85)
- [环境要求](#%E7%8E%AF%E5%A2%83%E8%A6%81%E6%B1%82)
- [驱动依赖](#%E9%A9%B1%E5%8A%A8%E4%BE%9D%E8%B5%96)
- [快速开始](#%E5%BF%AB%E9%80%9F%E5%BC%80%E5%A7%8B)
- [驱动配置](#%E9%A9%B1%E5%8A%A8%E9%85%8D%E7%BD%AE)
- [核心功能](#%E6%A0%B8%E5%BF%83%E5%8A%9F%E8%83%BD)
- [中间件](#%E4%B8%AD%E9%97%B4%E4%BB%B6)
- [上下文管理](#%E4%B8%8A%E4%B8%8B%E6%96%87%E7%AE%A1%E7%90%86)
- [工具类](#%E5%B7%A5%E5%85%B7%E7%B1%BB)
- [PHP 8.5 管道操作符](#php-85-%E7%AE%A1%E9%81%93%E6%93%8D%E4%BD%9C%E7%AC%A6%E6%94%AF%E6%8C%81)
- [API 参考](#api-%E5%8F%82%E8%80%83)
- [项目结构](#%E9%A1%B9%E7%9B%AE%E7%BB%93%E6%9E%84)
- [测试](#%E6%B5%8B%E8%AF%95)

特性
--

[](#特性)

- 多驱动支持（Redis、Beanstalkd、AMQP、Kafka、Database、Sync）
- 自动驱动检测与配置
- 统一的队列操作 API
- 支持延迟入队功能
- 支持批量操作（批量入队、批量出队）
- 支持队列监控功能
- 完善的异常处理机制
- 支持事务功能
- 中间件支持（重试、超时、日志等）
- 上下文管理（Context）
- 工具类支持（QueueUtil）
- 符合 PSR 规范（PSR-1、PSR-2、PSR-4、PSR-12）
- PHP 8.1+ 兼容，完美支持 PHP 8.5 管道操作符

安装
--

[](#安装)

```
composer require kode/queue
```

环境要求
----

[](#环境要求)

要求版本PHP>= 8.1ext-json\*ext-pdo\*驱动依赖
----

[](#驱动依赖)

驱动依赖包说明安装命令Redis`predis/predis`Redis 驱动所需`composer require predis/predis`Beanstalkd`pda/pheanstalk`Beanstalkd 驱动所需`composer require pda/pheanstalk`AMQP`php-amqplib/php-amqplib`AMQP 驱动所需`composer require php-amqplib/php-amqplib`Kafka`ext-rdkafka`PHP 扩展，Kafka 驱动所需`pecl install rdkafka`Database`ext-pdo`内置支持内置Sync无内置，用于测试内置快速开始
----

[](#快速开始)

### 基本使用

[](#基本使用)

```
use Kode\Queue\Factory;

// 创建队列实例
$queue = Factory::create([
    'default' => 'redis',
    'connections' => [
        'redis' => [
            'host' => '127.0.0.1',
            'port' => 6379,
        ],
    ],
]);

// 入队
$jobId = $queue->push('SendEmail', ['user_id' => 123]);

// 延迟入队（60秒后执行）
$jobId = $queue->later(60, 'SendEmail', ['user_id' => 123]);

// 批量入队
$jobIds = $queue->bulk(['SendEmail', 'ProcessOrder'], ['user_id' => 123]);

// 出队
$job = $queue->pop();
if ($job) {
    // 处理任务
    echo $job['job']; // 任务名称
    print_r($job['data']); // 任务数据
}

// 查看队列长度
$size = $queue->size();

// 查看队列统计信息
$stats = $queue->stats();
```

### 使用指定驱动

[](#使用指定驱动)

```
use Kode\Queue\Factory;

// 使用 Sync 驱动（同步执行，用于测试）
$queue = Factory::createWithDriver('sync');

// 使用 Redis 驱动
$queue = Factory::createWithDriver('redis', [
    'host' => '127.0.0.1',
    'port' => 6379,
    'database' => 0,
    'password' => null,
]);

// 使用 Database 驱动
$queue = Factory::createWithDriver('database', [
    'dsn' => 'mysql:host=127.0.0.1;dbname=queue',
    'username' => 'root',
    'password' => '',
    'table' => 'jobs',
]);

// 使用 Beanstalkd 驱动
$queue = Factory::createWithDriver('beanstalkd', [
    'host' => '127.0.0.1',
    'port' => 11300,
    'tube' => 'default',
]);

// 使用 AMQP 驱动
$queue = Factory::createWithDriver('amqp', [
    'host' => '127.0.0.1',
    'port' => 5672,
    'username' => 'guest',
    'password' => 'guest',
    'vhost' => '/',
    'queue' => 'default',
]);

// 使用 Kafka 驱动
$queue = Factory::createWithDriver('kafka', [
    'bootstrap_servers' => '127.0.0.1:9092',
    'topic' => 'queue',
    'group_id' => 'queue-consumer',
]);
```

驱动配置
----

[](#驱动配置)

### 完整配置示例

[](#完整配置示例)

```
$config = [
    'default' => 'redis',
    'connections' => [
        'redis' => [
            'driver' => 'redis',
            'host' => '127.0.0.1',
            'port' => 6379,
            'database' => 0,
            'password' => null,
            'options' => [],
        ],
        'beanstalkd' => [
            'driver' => 'beanstalkd',
            'host' => '127.0.0.1',
            'port' => 11300,
            'tube' => 'default',
        ],
        'amqp' => [
            'driver' => 'amqp',
            'host' => '127.0.0.1',
            'port' => 5672,
            'username' => 'guest',
            'password' => 'guest',
            'vhost' => '/',
            'queue' => 'default',
        ],
        'kafka' => [
            'driver' => 'kafka',
            'bootstrap_servers' => '127.0.0.1:9092',
            'topic' => 'queue',
            'group_id' => 'queue-consumer',
        ],
        'sync' => [
            'driver' => 'sync',
        ],
        'database' => [
            'driver' => 'database',
            'dsn' => 'mysql:host=127.0.0.1;dbname=queue',
            'username' => 'root',
            'password' => '',
            'table' => 'jobs',
        ],
    ],
];

$queue = Factory::create($config);
```

### 各驱动配置说明

[](#各驱动配置说明)

#### Redis 驱动

[](#redis-驱动)

参数类型默认值说明hoststring127.0.0.1Redis 服务器地址portint6379Redis 端口databaseint0数据库编号passwordstringnullnulloptionsarray\[\]Predis 选项#### Database 驱动

[](#database-驱动)

参数类型默认值说明dsnstring-PDO DSN 连接字符串usernamestringnull数据库用户名passwordstringnull数据库密码tablestringjobs任务表名#### Beanstalkd 驱动

[](#beanstalkd-驱动)

参数类型默认值说明hoststring127.0.0.1Beanstalkd 服务器地址portint11300Beanstalkd 端口tubestringdefault管道名称#### AMQP 驱动

[](#amqp-驱动)

参数类型默认值说明hoststring127.0.0.1RabbitMQ 服务器地址portint5672RabbitMQ 端口usernamestringguest用户名passwordstringguest密码vhoststring/虚拟主机queuestringdefault队列名称#### Kafka 驱动

[](#kafka-驱动)

参数类型默认值说明bootstrap\_serversstring127.0.0.1:9092Kafka 服务器地址topicstringqueue主题名称group\_idstringqueue-consumer消费者组ID核心功能
----

[](#核心功能)

### 全局队列和局部队列

[](#全局队列和局部队列)

```
use Kode\Queue\Factory;

$queue = Factory::createWithDriver('sync');

// 获取全局队列实例（单例模式）
$globalQueue1 = $queue->global('orders');
$globalQueue2 = $queue->global('orders');
// $globalQueue1 和 $globalQueue2 是同一个实例

// 全局队列应用场景：
// - 系统级任务队列
// - 跨模块共享的队列
// - 需要在多个地方访问的队列

// 获取局部队列实例（每次创建新实例）
$localQueue1 = $queue->local('emails');
$localQueue2 = $queue->local('emails');
// $localQueue1 和 $localQueue2 是不同实例

// 局部队列应用场景：
// - 临时任务队列
// - 单次操作的队列
// - 不需要跨模块共享的队列
```

### 使用事务

[](#使用事务)

```
use Kode\Queue\Factory;

$queue = Factory::createWithDriver('database');

try {
    $queue->beginTransaction();

    // 执行多个队列操作
    $jobId1 = $queue->push('Task1', ['data' => 'value1']);
    $jobId2 = $queue->push('Task2', ['data' => 'value2']);

    $queue->commit();
} catch (\Exception $e) {
    $queue->rollback();
    // 处理异常
}
```

### 延迟任务

[](#延迟任务)

```
use Kode\Queue\Factory;

$queue = Factory::createWithDriver('sync');

// 延迟 60 秒执行
$jobId = $queue->later(60, 'SendEmail', ['user_id' => 123]);

// 延迟 5 分钟执行
$jobId = $queue->later(300, 'ProcessOrder', ['order_id' => 456]);

// 延迟 1 小时执行
$jobId = $queue->later(3600, 'CleanupTask', ['type' => 'logs']);
```

### 批量操作

[](#批量操作)

```
use Kode\Queue\Factory;

$queue = Factory::createWithDriver('sync');

// 批量推送任务
$jobIds = $queue->bulk([
    'SendEmail',
    'SendSms',
    'SendPush',
], ['user_id' => 123]);

// 批量推送不同数据的任务
$jobs = [
    ['job' => 'SendEmail', 'data' => ['user_id' => 1]],
    ['job' => 'SendEmail', 'data' => ['user_id' => 2]],
    ['job' => 'SendEmail', 'data' => ['user_id' => 3]],
];

foreach ($jobs as $job) {
    $queue->push($job['job'], $job['data']);
}
```

中间件
---

[](#中间件)

### 内置中间件

[](#内置中间件)

中间件说明参数`LogMiddleware`记录队列操作日志`callable $logger` (可选)`RetryMiddleware`自动重试失败的任务`int $maxAttempts`, `int $delay`, `float $multiplier``RateLimitMiddleware`限制队列操作速率`int $capacity`, `float $rate`### 使用中间件

[](#使用中间件)

```
use Kode\Queue\Factory;
use Kode\Queue\Middleware\RetryMiddleware;
use Kode\Queue\Middleware\LogMiddleware;
use Kode\Queue\Middleware\RateLimitMiddleware;

$queue = Factory::createWithDriver('sync');

// 添加中间件
$queue->addMiddleware(new RetryMiddleware(3, 100, 2.0))
      ->addMiddleware(new LogMiddleware())
      ->addMiddleware(new RateLimitMiddleware(10, 1));

// 使用队列
$jobId = $queue->push('SendEmail', ['user_id' => 123]);
```

### 自定义中间件

[](#自定义中间件)

```
use Kode\Queue\Middleware\MiddlewareInterface;

class CustomMiddleware implements MiddlewareInterface {
    public function handle(callable $next, string $method, array $parameters) {
        // 前置处理
        echo "Before: $method\n";

        // 执行下一个处理器
        $result = $next($parameters);

        // 后置处理
        echo "After: $method\n";

        return $result;
    }
}

// 使用自定义中间件
$queue->addMiddleware(new CustomMiddleware());
```

上下文管理
-----

[](#上下文管理)

`Context` 类用于封装和管理队列任务的上下文信息，提供便捷的方法来访问和操作任务数据。

### 创建上下文

[](#创建上下文)

```
use Kode\Queue\Context\Context;

// 从任务数据创建上下文
$context = new Context([
    'id' => 'job_123',
    'job' => 'SendEmail',
    'data' => ['user_id' => 123],
    'attempts' => 0,
    'created_at' => time(),
]);

// 从数组创建
$context = Context::fromArray($jobData);

// 从 JSON 创建
$context = Context::fromJson('{"id":"job_123","job":"SendEmail",...}');
```

### 获取任务信息

[](#获取任务信息)

```
// 获取任务ID
$jobId = $context->getJobId();        // 'job_123'

// 获取任务名称
$jobName = $context->getJob();        // 'SendEmail'

// 获取任务数据
$jobData = $context->getData();       // ['user_id' => 123]

// 获取重试次数
$attempts = $context->getAttempts();  // 0

// 获取创建时间
$createdAt = $context->getCreatedAt(); // 时间戳

// 获取队列名称
$queue = $context->getQueue();        // 队列名称

// 获取完整负载
$payload = $context->getPayload();    // 完整数组数据
```

### 操作上下文

[](#操作上下文)

```
// 增加重试次数
$context->incrementAttempts();

// 转换为数组
$payload = $context->toArray();

// 转换为 JSON
$json = $context->toJson();
```

### 在任务处理器中使用

[](#在任务处理器中使用)

```
use Kode\Queue\Context\Context;

class SendEmailHandler {
    public function handle(array $jobData) {
        $context = new Context($jobData);

        // 获取任务信息
        $userId = $context->getData()['user_id'];
        $attempts = $context->getAttempts();

        // 执行任务逻辑
        try {
            $this->sendEmail($userId);
        } catch (\Exception $e) {
            // 记录重试
            $context->incrementAttempts();

            // 判断是否超过最大重试次数
            if ($context->getAttempts() >= 3) {
                throw $e;
            }

            // 重新入队
            return false;
        }

        return true;
    }
}
```

工具类
---

[](#工具类)

`QueueUtil` 类提供队列操作中常用的工具方法。

### 生成任务ID

[](#生成任务id)

```
use Kode\Queue\Util\QueueUtil;

// 生成唯一任务ID
$jobId = QueueUtil::generateJobId();
// 输出: 67e8f12345678.12345678
```

### 创建和解析负载

[](#创建和解析负载)

```
use Kode\Queue\Util\QueueUtil;

// 创建任务负载
$payload = QueueUtil::createPayload('SendEmail', ['user_id' => 123]);
// 输出: {"job":"SendEmail","data":{"user_id":123},"id":"...","attempts":0,"created_at":1234567890}

// 解析任务负载
$data = QueueUtil::parsePayload($payload);
// 输出: ['job' => 'SendEmail', 'data' => ['user_id' => 123], ...]
```

### 检查任务状态

[](#检查任务状态)

```
use Kode\Queue\Util\QueueUtil;

// 检查任务是否就绪（用于延迟任务）
$job = ['available_at' => time() - 10];
$isReady = QueueUtil::isJobReady($job);  // true

$job = ['available_at' => time() + 60];
$isReady = QueueUtil::isJobReady($job);  // false
```

### 计算延迟

[](#计算延迟)

```
use Kode\Queue\Util\QueueUtil;

// 计算延迟后的时间戳
$timestamp = QueueUtil::calculateDelay(60);  // 当前时间 + 60秒
```

### 格式化队列大小

[](#格式化队列大小)

```
use Kode\Queue\Util\QueueUtil;

// 格式化队列大小
echo QueueUtil::formatSize(500);     // "500"
echo QueueUtil::formatSize(1500);    // "1.50K"
echo QueueUtil::formatSize(1500000); // "1.50M"
```

### 验证名称

[](#验证名称)

```
use Kode\Queue\Util\QueueUtil;

// 验证队列名称
QueueUtil::validateQueueName('my-queue');    // true
QueueUtil::validateQueueName('my_queue');    // true
QueueUtil::validateQueueName('my.queue');    // true
QueueUtil::validateQueueName('my queue');    // false (包含空格)

// 验证任务名称
QueueUtil::validateJobName('SendEmail');         // true
QueueUtil::validateJobName('App\Jobs\SendEmail'); // true
QueueUtil::validateJobName('123SendEmail');      // false (数字开头)
```

### 指数退避

[](#指数退避)

```
use Kode\Queue\Util\QueueUtil;

// 计算指数退避延迟时间（毫秒）
QueueUtil::exponentialBackoff(1, 100, 2.0);  // 100ms (第1次重试)
QueueUtil::exponentialBackoff(2, 100, 2.0);  // 200ms (第2次重试)
QueueUtil::exponentialBackoff(3, 100, 2.0);  // 400ms (第3次重试)
QueueUtil::exponentialBackoff(4, 100, 2.0);  // 800ms (第4次重试)

// 自定义参数
QueueUtil::exponentialBackoff(3, 50, 1.5);   // 112ms (基础延迟50ms，乘数1.5)
```

PHP 8.5 管道操作符支持
---------------

[](#php-85-管道操作符支持)

PHP 8.5 引入了管道操作符 `|>`，本包完美支持这一新特性。

### 传统写法

[](#传统写法)

```
use Kode\Queue\Factory;
use Kode\Queue\Middleware\LogMiddleware;

$queue = Factory::createWithDriver('sync');
$queue->addMiddleware(new LogMiddleware());
$jobId = $queue->push('SendEmail', ['user_id' => 123]);
```

### PHP 8.5 管道操作符写法

[](#php-85-管道操作符写法)

```
use Kode\Queue\Factory;
use Kode\Queue\Middleware\LogMiddleware;
use Kode\Queue\Middleware\RetryMiddleware;

// 基本管道操作
$jobId = Factory::createWithDriver('sync')
    |> fn($q) => $q->push('SendEmail', ['user_id' => 123]);

// 管道操作与中间件
$jobId = Factory::createWithDriver('sync')
    |> fn($q) => $q->addMiddleware(new LogMiddleware())
    |> fn($q) => $q->addMiddleware(new RetryMiddleware(3, 100, 2.0))
    |> fn($q) => $q->push('SendEmail', ['user_id' => 123]);

// 管道操作与全局队列
$jobId = Factory::createWithDriver('sync')
    |> fn($q) => $q->global('emails')
    |> fn($q) => $q->push('SendEmail', ['user_id' => 123]);

// 管道操作与延迟任务
$jobId = Factory::createWithDriver('sync')
    |> fn($q) => $q->later(60, 'DelayedJob', ['data' => 'delayed']);

// 管道操作与批量任务
$jobIds = Factory::createWithDriver('sync')
    |> fn($q) => $q->bulk(['Job1', 'Job2', 'Job3'], ['data' => 'bulk']);
```

### 兼容 PHP 8.1-8.4 的管道方法

[](#兼容-php-81-84-的管道方法)

对于 PHP 8.5 以下版本，可以使用 `pipe()` 方法实现类似功能：

```
use Kode\Queue\Factory;
use Kode\Queue\Middleware\LogMiddleware;

// 使用 pipe 方法
$jobId = Factory::createWithDriver('sync')
    ->pipe(fn($q) => $q->addMiddleware(new LogMiddleware()))
    ->pipe(fn($q) => $q->push('SendEmail', ['user_id' => 123]));

// 链式 pipe 调用
$result = Factory::createWithDriver('sync')
    ->pipe(fn($q) => $q->addMiddleware(new LogMiddleware()))
    ->pipe(fn($q) => $q->push('Task1', ['data' => 'value1']))
    ->pipe(fn($q) => $q->push('Task2', ['data' => 'value2']))
    ->pipe(fn($q) => $q->size());
```

API 参考
------

[](#api-参考)

### QueueInterface

[](#queueinterface)

方法参数返回值说明`push``$job, array $data = [], string $queue = null``string`推送任务到队列`pushRaw``string $payload, string $queue = null, array $options = []``string`推送原始负载到队列`later``int $delay, $job, array $data = [], string $queue = null``string`延迟推送任务到队列`bulk``array $jobs, array $data = [], string $queue = null``array`批量推送任务到队列`pop``string $queue = null``mixed`从队列中取出下一个任务`size``string $queue = null``int`获取队列大小`delete``string $jobId, string $queue = null``bool`从队列中删除任务`release``int $delay, string $jobId, string $queue = null``bool`将任务释放回队列`stats``string $queue = null``array`获取队列统计信息`beginTransaction`-`void`开始事务`commit`-`void`提交事务`rollback`-`void`回滚事务`global``string $queue = 'default'``QueueInterface`获取全局队列实例`local``string $queue = 'default'``QueueInterface`获取局部队列实例`pipe``callable $callback``mixed`管道操作`addMiddleware``MiddlewareInterface $middleware``$this`添加中间件项目结构
----

[](#项目结构)

```
src/
├── Driver/                  # 驱动目录
│   ├── DriverInterface.php  # 驱动接口
│   ├── SyncDriver.php       # 同步驱动
│   ├── DatabaseDriver.php   # 数据库驱动
│   ├── RedisDriver.php      # Redis 驱动
│   ├── BeanstalkdDriver.php # Beanstalkd 驱动
│   ├── AmqpDriver.php       # AMQP 驱动
│   └── KafkaDriver.php      # Kafka 驱动
├── Exception/               # 异常目录
│   ├── QueueException.php   # 队列异常基类
│   ├── DriverException.php  # 驱动异常
│   └── TransactionException.php # 事务异常
├── Middleware/              # 中间件目录
│   ├── MiddlewareInterface.php # 中间件接口
│   ├── LogMiddleware.php    # 日志中间件
│   ├── RetryMiddleware.php  # 重试中间件
│   └── RateLimitMiddleware.php # 限流中间件
├── Context/                 # 上下文目录
│   └── Context.php          # 队列操作上下文
├── Util/                    # 工具目录
│   └── QueueUtil.php        # 队列工具类
├── AbstractQueue.php        # 抽象队列基类
├── Factory.php              # 工厂类
└── QueueInterface.php       # 队列接口

```

测试
--

[](#测试)

```
# 运行测试
composer test

# 生成测试覆盖率报告
composer test-coverage
```

###  Health Score

37

—

LowBetter than 83% of packages

Maintenance88

Actively maintained with recent releases

Popularity5

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity42

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

61d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/ab9b61142c551649e12c6021d20db6aad7f389f91a220efec06f4af44dd8b5cd?d=identicon)[kodephp](/maintainers/kodephp)

---

Top Contributors

[![mofeier](https://avatars.githubusercontent.com/u/16829186?v=4)](https://github.com/mofeier "mofeier (3 commits)")

---

Tags

phpdatabaseredisqueuebeanstalkdAMQPsyncpipelinephp85kafkaphp81

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/kode-queue/health.svg)

```
[![Health](https://phpackages.com/badges/kode-queue/health.svg)](https://phpackages.com/packages/kode-queue)
```

###  Alternatives

[spiritix/lada-cache

A Redis based, automated and scalable database caching layer for Laravel

591444.8k2](/packages/spiritix-lada-cache)[mmucklo/queue-bundle

Symfony2/3/4/5 Queue Bundle (for background jobs) supporting Mongo (Doctrine ODM), Mysql (and any Doctrine ORM), RabbitMQ, Beanstalkd, Redis, and ... {write your own}

120839.8k](/packages/mmucklo-queue-bundle)[awssat/laravel-sync-migration

Laravel tool helps to sync migrations without refreshing the database

10923.2k](/packages/awssat-laravel-sync-migration)[anorgan/qutee

Simple queue manager and task processor for PHP

711.9k1](/packages/anorgan-qutee)[enqueue/magento2-enqueue

Message Queue solutions for Magento2. Supports RabbitMQ, AMQP, STOMP, Amazon SQS, Kafka, Redis, Google PubSub, Gearman, Beanstalk, Google PubSub

4918.8k](/packages/enqueue-magento2-enqueue)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)