Laravel 的消息队列剖析

最新推荐文章于 2023-09-18 16:55:17 发布
最新推荐文章于 2023-09-18 16:55:17 发布
阅读量453 收藏 2
点赞数
分类专栏： PHP
原文链接：https://learnku.com/articles/4169/analysis-of-laravel-message-queue
版权

在实际工作中也不止遇见过一次这个问题，我在想着以前是怎么处理的呢？我记得当初在上家公司的时候直接使用的是 laravel 的 queue 来实现的。当然，这里说的 laravel 的 queue 实际上也是基于 redis 的队列实现的。正好今天遇上这个问题，追下底层机制。

使用如下：http://learnku.com/docs/laravel/5.3/queues

// 创建10分钟后执行的任务

$job = (new ProcessPodcast($pocast))
            ->delay(Carbon::now()->addMinutes(10));

dispatch($job);

//启动队列命令
php artisan queue:work

分发部分

首先看 dispatch 这边做的事情：

dispatch 函数首先就是调用

return app(Dispatcher::class)->dispatch($job);
// Illuminate\Contracts\Bus\Dispatcher

首先需要理解这里的 Dispatcher::class 实际注入的是哪个类。

看到 vendor/laravel/framework/src/Illuminate/Bus/BusServiceProvider.php:26，有

public function register()
{
    $this->app->singleton('Illuminate\Bus\Dispatcher', function ($app) {
        return new Dispatcher($app, function ($connection = null) use ($app) {
            return $app['Illuminate\Contracts\Queue\Factory']->connection($connection);
        });
    });

    $this->app->alias(
        'Illuminate\Bus\Dispatcher', 'Illuminate\Contracts\Bus\Dispatcher'
    );

    $this->app->alias(
        'Illuminate\Bus\Dispatcher', 'Illuminate\Contracts\Bus\QueueingDispatcher'
    );
}

所以最后是实例化了 Illuminate\Bus\Dispatcher

看看它的 dispatch 函数做了啥？

public function dispatch($command)
{
    if ($this->queueResolver && $this->commandShouldBeQueued($command)) {
        return $this->dispatchToQueue($command);
    } else {
        return $this->dispatchNow($command);
    }
}

假设我们的 dispatch 是基于队列的（ShouldQueue）。那么就是走 dispatchToQueue，最终，走的是 pushCommandToQueue

protected function pushCommandToQueue($queue, $command)
{
    ...

    if (isset($command->delay)) {
        return $queue->later($command->delay, $command);
    }
    ...
}

这里的 queue 就是队列的范畴了，假设我们用的队列是 redis。（队列的解析器就是 singleton 的时候传入的 Cluster）。最终这里落入的是 vendor/laravel/framework/src/Illuminate/Queue/RedisQueue.php:111 的

public function later($delay, $job, $data = '', $queue = null)
{
    $payload = $this->createPayload($job, $data);

    $this->getConnection()->zadd(
        $this->getQueue($queue).':delayed', $this->getTime() + $this->getSeconds($delay), $payload
    );

    return Arr::get(json_decode($payload, true), 'id');
}

这下就看清楚了：

laravel 的延迟队列，使用的是 zadd 命令，往 {$queue}:delayed，中插入一条 job 信息，它的 score 是执行时间。

（得到这条结论还真 tmd 是不容易）

队列监听部分

队列监听命令来自于： php artisan queue:work

命令行的入口就不追踪了，直接到 vendor/laravel/framework/src/Illuminate/Queue/Console/WorkCommand.php:29 类

protected function runWorker($connection, $queue)
{
    $this->worker->setCache($this->laravel['cache']->driver());

    return $this->worker->{$this->option('once') ? 'runNextJob' : 'daemon'}(
        $connection, $queue, $this->gatherWorkerOptions()
    );
}

这里的 daemon 和 runNextJob 是只跑一次还是持续跑的意思，我们当然假定是以 daemon 的形式在跑。

这里的 worker 是 vendor/laravel/framework/src/Illuminate/Queue/Worker.php:78

public function daemon($connectionName, $queue, WorkerOptions $options)
{
    $lastRestart = $this->getTimestampOfLastQueueRestart();

    while (true) {
        $this->registerTimeoutHandler($options);

        if ($this->daemonShouldRun($options)) {
            $this->runNextJob($connectionName, $queue, $options);
        } else {
            $this->sleep($options->sleep);
        }

        if ($this->memoryExceeded($options->memory) ||
            $this->queueShouldRestart($lastRestart)) {
            $this->stop();
        }
    }
}

这里的代码就值得我们自己写 deamon 的时候来参考了，它考虑了 timeout，考虑了 memory 的情况。

而 runNextJob 的命令实际上就很清晰了

public function runNextJob($connectionName, $queue, WorkerOptions $options)
{
    ...
        $job = $this->getNextJob(
            $this->manager->connection($connectionName), $queue
        );

        ...
            return $this->process(
                $connectionName, $job, $options
            );
    ...
}

这里的 Manager 对应的是 QueueManager, 这个类内部会创建一个 connector（vendor/laravel/framework/src/Illuminate/Queue/Connectors/RedisConnector.php:30）

public function connect(array $config)
{
    return new RedisQueue(
        $this->redis, $config['queue'],
        Arr::get($config, 'connection', $this->connection),
        Arr::get($config, 'retry_after', 60)
    );
}

看到这里就明白了，最后还是掉落到 RedisQueue 中。 很好，和我们前面的任务分发终于对上了，圈子差不多画完了，我们可以看到曙光了。

追到 RedisQueue 里面，看它的 pop 行为。

public function pop($queue = null)
{
    $original = $queue ?: $this->default;

    $queue = $this->getQueue($queue);

    $this->migrateExpiredJobs($queue.':delayed', $queue);

    if (! is_null($this->expire)) {
        $this->migrateExpiredJobs($queue.':reserved', $queue);
    }

    list($job, $reserved) = $this->getConnection()->eval(
        LuaScripts::pop(), 2, $queue, $queue.':reserved', $this->getTime() + $this->expire
    );

    if ($reserved) {
        return new RedisJob($this->container, $this, $job, $reserved, $original);
    }
}

这段就是精华了。它做了什么事情呢？

先看 migrateExpiredJobs:

public function migrateExpiredJobs($from, $to)
{
    $this->getConnection()->eval(
        LuaScripts::migrateExpiredJobs(), 2, $from, $to, $this->getTime()
    );
}

这里的 eval 就是对应 redis 的 eval 操作，https://redis.io/commands/eval，2 是说明后面有两个 key，最后一个 getTime () 获取的是 arg。
下面就看 lua 脚本了。

public static function migrateExpiredJobs()
{
    return <<<'LUA'
local val = redis.call('zrangebyscore', KEYS[1], '-inf', ARGV[1])
if(next(val) ~= nil) then
redis.call('zremrangebyrank', KEYS[1], 0, #val - 1)
for i = 1, #val, 100 do
    redis.call('rpush', KEYS[2], unpack(val, i, math.min(i+99, #val)))
end
end
return true
LUA;
}

结合起来看就是：

  • 使用 zrangebyscore 和 zremrangebyrank 从 {queue}:delayed 队列中，从 - inf 到 now 的任务拿出来。
  • 用 rpush 的方式存入到默认 queue 中（后续就是放入到 {queue}:reserved ）

这个 zrangebyscore 就是判断延迟任务是否应该执行的操作了。

然后就进行的是

list($job, $reserved) = $this->getConnection()->eval(
    LuaScripts::pop(), 2, $queue, $queue.':reserved', $this->getTime() + $this->expire
);

这里的 LuaScripts::pop () 如下：

public static function pop()
{
    return <<<'LUA'
local job = redis.call('lpop', KEYS[1])
local reserved = false
if(job ~= false) then
reserved = cjson.decode(job)
reserved['attempts'] = reserved['attempts'] + 1
reserved = cjson.encode(reserved)
redis.call('zadd', KEYS[2], ARGV[1], reserved)
end
return {job, reserved}
LUA;
}

做了下面操作：

  • 把默认队列中的任务 lpop 出来
  • 将他的 attempts 次数 + 1
  • zadd 存入 {queue}:reserved 队列，score 为 now+60 (默认的过期时间)

最后，我就返回这个 job，这里结束了 getNextJob 的过程

process 过程就是调用了一下：vendor/laravel/framework/src/Illuminate/Queue/Worker.php:187

public function process($connectionName, $job, WorkerOptions $options)
{
    try {
        $this->raiseBeforeJobEvent($connectionName, $job);

        $this->markJobAsFailedIfAlreadyExceedsMaxAttempts(
            $connectionName, $job, (int) $options->maxTries
        );

        // Here we will fire off the job and let it process. We will catch any exceptions so
        // they can be reported to the developers logs, etc. Once the job is finished the
        // proper events will be fired to let any listeners know this job has finished.
        $job->fire();

        $this->raiseAfterJobEvent($connectionName, $job);
    } catch (Exception $e) {
        $this->handleJobException($connectionName, $job, $options, $e);
    } catch (Throwable $e) {
        $this->handleJobException(
            $connectionName, $job, $options, new FatalThrowableError($e)
        );
    }
}

$this->events->fire(new Events\JobProcessing(
    $connectionName, $job
));

这里的 raiseBeforeJobEvent 和 raiseAfterJobEvent 又是使用 event 和 listener 的形式来做处理的。这里的 $this->events 是 vendor/laravel/framework/src/Illuminate/Events/Dispatcher.php:197

这里就是触发了一个 Events\JobProcessing 事件，我们现在要找到对应的 lister：

答案是在 QueueManager 中定义的

/**
 * Register an event listener for the before job event.
 *
 * @param  mixed  $callback
 * @return void
 */
public function before($callback)
{
    $this->app['events']->listen(Events\JobProcessing::class, $callback);
}

/**
 * Register an event listener for the after job event.
 *
 * @param  mixed  $callback
 * @return void
 */
public function after($callback)
{
    $this->app['events']->listen(Events\JobProcessed::class, $callback);
}

换句话说，我们希望监听一个 job 开始和结束的时候，我们可以使用 QueueManager 的 before，after 来监听。比如发个邮件，唱唱小曲啥的。

那么这里我们，从 {queue}:reserved 中获取了 job 之后（这里的 job 是 RedisJob），我们是什么时候触发的 delete 呢？是在

$job->fire();

这个 fire 是 RedisJob (vendor/laravel/framework/src/Illuminate/Queue/Jobs/RedisJob.php) 但继承来自 vendor/laravel/framework/src/Illuminate/Queue/Jobs/Job.php:72， 经过调用 CallQueuedHandler，最终会落到
vendor/laravel/framework/src/Illuminate/Queue/RedisQueue.php:154

public function deleteReserved($queue, $job)
{
    $this->getConnection()->zrem($this->getQueue($queue).':reserved', $job);
}

这里就是将 job 从 {queue}:reserved 队列中删除。

至此，整个队列及延迟机制就处理完了。

实际
我们实际监听一下 redis 就可以验证结果：

// 使用dispatch
1489802272.491060 [0 127.0.0.1:63798] "SELECT" "0"
1489802272.491513 [0 127.0.0.1:63798] "ZADD" "queues:default:delayed" "1489802332" "{\"job\":\"Illuminate\\\\Queue\\\\CallQueuedHandler@call\",\"data\":{\"commandName\":\"App\\\\Jobs\\\\DelayTestJob\",\"command\":\"O:21:\\\"App\\\\Jobs\\\\DelayTestJob\\\":4:{s:6:\\\"\\u0000*\\u0000job\\\";N;s:10:\\\"connection\\\";N;s:5:\\\"queue\\\";N;s:5:\\\"delay\\\";O:13:\\\"Carbon\\\\Carbon\\\":3:{s:4:\\\"date\\\";s:26:\\\"2017-03-18 01:58:52.000000\\\";s:13:\\\"timezone_type\\\";i:3;s:8:\\\"timezone\\\";s:3:\\\"UTC\\\";}}\"},\"id\":\"q7ss6fRgCbMNHhCv6gOXX0Or7B43blU9\",\"attempts\":1}"

// 1分钟后
1489802333.957500 [0 127.0.0.1:63792] "EVAL" "local val = redis.call('zrangebyscore', KEYS[1], '-inf', ARGV[1])\nif(next(val) ~= nil) then\n    redis.call('zremrangebyrank', KEYS[1], 0, #val - 1)\n    for i = 1, #val, 100 do\n        redis.call('rpush', KEYS[2], unpack(val, i, math.min(i+99, #val)))\n    end\nend\nreturn true" "2" "queues:default:delayed" "queues:default" "1489802333"
1489802333.957563 [0 lua] "zrangebyscore" "queues:default:delayed" "-inf" "1489802333"
1489802333.957586 [0 lua] "zremrangebyrank" "queues:default:delayed" "0" "0"
1489802333.958628 [0 lua] "rpush" "queues:default" "{\"job\":\"Illuminate\\\\Queue\\\\CallQueuedHandler@call\",\"data\":{\"commandName\":\"App\\\\Jobs\\\\DelayTestJob\",\"command\":\"O:21:\\\"App\\\\Jobs\\\\DelayTestJob\\\":4:{s:6:\\\"\\u0000*\\u0000job\\\";N;s:10:\\\"connection\\\";N;s:5:\\\"queue\\\";N;s:5:\\\"delay\\\";O:13:\\\"Carbon\\\\Carbon\\\":3:{s:4:\\\"date\\\";s:26:\\\"2017-03-18 01:58:52.000000\\\";s:13:\\\"timezone_type\\\";i:3;s:8:\\\"timezone\\\";s:3:\\\"UTC\\\";}}\"},\"id\":\"q7ss6fRgCbMNHhCv6gOXX0Or7B43blU9\",\"attempts\":1}"
1489802333.959572 [0 127.0.0.1:63792] "EVAL" "local val = redis.call('zrangebyscore', KEYS[1], '-inf', ARGV[1])\nif(next(val) ~= nil) then\n    redis.call('zremrangebyrank', KEYS[1], 0, #val - 1)\n    for i = 1, #val, 100 do\n        redis.call('rpush', KEYS[2], unpack(val, i, math.min(i+99, #val)))\n    end\nend\nreturn true" "2" "queues:default:reserved" "queues:default" "1489802333"
1489802333.959672 [0 lua] "zrangebyscore" "queues:default:reserved" "-inf" "1489802333"
1489802333.959866 [0 127.0.0.1:63792] "EVAL" "local job = redis.call('lpop', KEYS[1])\nlocal reserved = false\nif(job ~= false) then\n    reserved = cjson.decode(job)\n    reserved['attempts'] = reserved['attempts'] + 1\n    reserved = cjson.encode(reserved)\n    redis.call('zadd', KEYS[2], ARGV[1], reserved)\nend\nreturn {job, reserved}" "2" "queues:default" "queues:default:reserved" "1489802343"
1489802333.959938 [0 lua] "lpop" "queues:default"
1489802333.959965 [0 lua] "zadd" "queues:default:reserved" "1489802343" "{\"id\":\"q7ss6fRgCbMNHhCv6gOXX0Or7B43blU9\",\"attempts\":2,\"data\":{\"command\":\"O:21:\\\"App\\\\Jobs\\\\DelayTestJob\\\":4:{s:6:\\\"\\u0000*\\u0000job\\\";N;s:10:\\\"connection\\\";N;s:5:\\\"queue\\\";N;s:5:\\\"delay\\\";O:13:\\\"Carbon\\\\Carbon\\\":3:{s:4:\\\"date\\\";s:26:\\\"2017-03-18 01:58:52.000000\\\";s:13:\\\"timezone_type\\\";i:3;s:8:\\\"timezone\\\";s:3:\\\"UTC\\\";}}\",\"commandName\":\"App\\\\Jobs\\\\DelayTestJob\"},\"job\":\"Illuminate\\\\Queue\\\\CallQueuedHandler@call\"}"
1489802333.963223 [0 127.0.0.1:63792] "ZREM" "queues:default:reserved" "{\"id\":\"q7ss6fRgCbMNHhCv6gOXX0Or7B43blU9\",\"attempts\":2,\"data\":{\"command\":\"O:21:\\\"App\\\\Jobs\\\\DelayTestJob\\\":4:{s:6:\\\"\\u0000*\\u0000job\\\";N;s:10:\\\"connection\\\";N;s:5:\\\"queue\\\";N;s:5:\\\"delay\\\";O:13:\\\"Carbon\\\\Carbon\\\":3:{s:4:\\\"date\\\";s:26:\\\"2017-03-18 01:58:52.000000\\\";s:13:\\\"timezone_type\\\";i:3;s:8:\\\"timezone\\\";s:3:\\\"UTC\\\";}}\",\"commandName\":\"App\\\\Jobs\\\\DelayTestJob\"},\"job\":\"Illuminate\\\\Queue\\\\CallQueuedHandler@call\"}"

精简下路径就是：

// 第一步：先往delayed队列中插入job
1489802272.491513 [0 127.0.0.1:63798] "ZADD" "queues:default:delayed" "1489802332" {job}

// 第二步，将delayed队列中到期的job取出，并且rpush进default队列
1489802333.957563 [0 lua] "zrangebyscore" "queues:default:delayed" "-inf" "1489802333"
1489802333.957586 [0 lua] "zremrangebyrank" "queues:default:delayed" "0" "0"
1489802333.958628 [0 lua] "rpush" "queues:default" {job}

// 第三步，从default队列中lpop出job
1489802333.959938 [0 lua] "lpop" "queues:default"

// 第四步，zadd到default:reserved
1489802333.959965 [0 lua] "zadd" "queues:default:reserved" "1489802343" {job}

// 第五步，程序处理这个job

// 第六步，讲job从default:reserved中删除
1489802333.963223 [0 127.0.0.1:63792] "ZREM" "queues:default:reserved" {job}
符合预期。

总结
laravel 这边的延迟队列使用了三个队列。

queue:default:delayed // 存储延迟任务
queue:default // 存储 “生” 任务，就是未处理任务
queue:default:reserved // 存储待处理任务
任务在三个队列中进行轮转，最后一定进入到 queue:default:reserved，并且成功后把任务从这个队列中删除。

其间还使用了 lua 脚本，所以至少 laravel5.3（本文的 laravel 环境）在无 lua 脚本支持的 redis 版本是跑不了的。

它用三个队列把所有的步骤给原子了，所以并没有使用 multi 等操作。也是防止了锁的使用把。每一步操作失败了，都会有后续的步骤继续帮忙完成，记录等行为的。

————————————————
原文作者：轩脉刃
转自链接：https://learnku.com/articles/4169/analysis-of-laravel-message-queue
版权声明：著作权归作者所有。商业转载请联系作者获得授权，非商业转载请保留以上作者信息和原文链接。laravel 的消息队列剖析

oye-game
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
laravel 任务队列_基于 Redis 在 Laravel 中实现消息队列及底层源码探究
weixin_39979245的博客
12-29 656
消息队列简介一个完整的队列系统由以下三个组件组成：队列(Queue)消息(Message)处理进程(Worker)对应的基本工作流程是生产者(业务代码)先将消息数据推送到队列，然后再通过其他的处理进程来消费队列中的消息数据，从而实现生产者和消费者之间的解耦。因此，消息队列非常适用于一些需要异步执行的耗时操作(比如邮件发送、文件上传)，或者业务临时的高并发操作(比如秒杀、消息推送)，对于提...
Laravel Queue RabbitMQ：高效异步任务处理的利器
最新发布
gitblog_00073的博客
04-19 737
Laravel Queue RabbitMQ：高效异步任务处理的利器 项目地址:https://gitcode.com/vladimir-yuldashev/laravel-queue-rabbitmq Laravel Queue RabbitMQ 是一个由开发者 Vladimir Yuldashev 创建的开源项目，它将RabbitMQ消息队列与Laravel框架集成，以实现更高效的异步任务处理...
laravel 消息队列浅析
weixin_34363171的博客
11-29 200
　　laravel支持消息队列，发短信，发送消息通知 用起来很方便，延时队列还可以用来方式晚上发短信骚扰用户。但是使用的时候遇到了不少问题，比如laravel队列的重试功能，真的是让人很慌，打款或者消息推送，哪个重复了都会造成很大的影响。接下来就列举几个我遇到过的问题，总结一下，防止再次踩坑。 第一点： 使用worker监听，出队的代码如果又修改，那么上线必须重启监听 第二...
PHP+Laravel+RabbitMQ实现异步延迟消息队列(库存归还)
05-09 1926
一、前言 需求：电商秒杀场景中，如果用户下单10分钟未支付，需要进行库存归还 本篇是用PHP+Laravel+RabbitMQ来实现异步延迟消息队列 二、场景 在电商项目中，当我们下单之后，一般需要 20 分钟之内或者 30 分钟之内付款，否则订单就会进入异常处理逻辑中，被取消，那么进入到异常处理逻辑中，就可以当成是一个延迟队列 公司的会议预定系统，在会议预定成功后，会在会议开始前半小时通知所有预定该会议的用户 安全工单超过 24 小时未处理，则自动拉企业微信群提醒相关责任人 用户下单外卖以后，距离
laravel 使用rabbitmq 的简单使用
Cccfffff的博客
05-23 778
【代码】laravel 使用rabbitmq 的简单使用。
laravel6 使用rabbitmq报错：Call to a member function make() on null at Queue\\Jobs\\Job.php:215
lauwen
04-03 2564
报错信息 [previous exception] [object] (Error(code: 0): Call to a member function make() on null at ~\\vendor\\laravel\\framework\\src\\Illuminate\\Queue\\Jobs\\Job.php:215) 另外，以下情况报错可能也是由于此问题产生，可以参考是否能够解决： PhpAmqpLib\Exception\AMQPProtocolChannelExcept.
Laravel框架队列原理与用法分析
10-18
主要介绍了Laravel框架队列原理与用法,结合实例形式分析了Laravel框架队列的原理、使用方法及相关操作注意事项,需要的朋友可以参考下
源码分析 Laravel 重复执行同一个队列任务的原因
01-20
laravel 的队列服务对各种不同的后台队列服务提供了统一的 API。队列允许你延迟执行消耗时间的任务，比如发送一封邮件。这样可以有效的降低请求响应的时间。 发现问题 在 Laravel 中使用 Redis 处理队列任务，框架...
laravel中Redis队列监听中断的分析
12-16
1、linxu挂起队列监听 nohup php artisan queue:listen --timeout=90 --tries=1 >> /dev/null 2>&1 & 2、发现问题（日志） In Process.php line 429: The process has been sinaled with signal "1". 3、查询...
Laravel队列的使用
小坚的技术博客
12-03 499
1.命令行执行下面的命令，生成job文件 php artisan make:job 任务名 2.在app/Jobs目录下找到任务文件，在handle()方法中写任务具体代码 3.在控制器中调用该队列的dispatch()方法，相当于往队列添加一个任务 SendEmail::dispatch(); //SendEmail是我的任务文件类名 4.在命令行启动队列 php artisan queue:work 5.在控制器或者其他调用dispatch()方法的地方会往队列插入任务到队列，队列会自动执行，也就
[李景山php]每天laravel-20160901|Dispatcher-1
景山编程-顺道编程
06-16 603
namespace Illuminate\Events;use Exception; use ReflectionClass; use Illuminate\Support\Str; use Illuminate\Container\Container; use Illuminate\Contracts\Broadcasting\ShouldBroadcast; use Illuminate\Con
Laravel开发-dispatcher
08-27
Laravel开发-dispatcher 在应用程序中计划Artisan命令
laravel-queue-rabbitmq：Laravel队列的RabbitMQ驱动程序。 支持Laravel Horizo​​n
02-03
Laravel的RabbitMQ队列驱动程序 支援政策 只有最新版本才能获得新功能。 错误修复将使用以下方案提供： 套餐版本 Laravel版本 错误修复，直到 9 6 2021年10月5日 10 6、7 2021年10月5日 11 8 2021年4月6日 安装 您可以使用以下命令通过composer安装此软件包： composer require vladimir-yuldashev/laravel-queue-rabbitmq 包将自动注册。 将连接添加到config/queue.php ： 'connections' => [ // ... 'rabb
laravel框架 - rabbitmq消息队列（使用laravel-queue-rabbitmq）
荒的博客
09-18 656
rabbitmq消息队列（使用laravel-queue-rabbitmq）
Laravel DatabaseQueue 基本知识点
余璜的技术博客
09-01 1740
基本知识点包括：Container; php serialize, deseriaize; json_encode, json_decode
带你五分钟了解Laravel模型事件的实现原理
pipujopijhpo的博客
04-08 386
模型事件在 Laravel 的世界中，你对 Eloquent 大多数操作都会或多或少的触发一些模型事件，下面这篇文章主要给大家介绍了关于Laravel模型事件的实现原理，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴。 前言 Laravel的ORM模型在一些特定的情况下，会触发一系列的事件，目前支持的事件有这些：creating, created, updating, updated, saving, saved, deleting, deleted, restoring, restored，那么在
laravel 队列操作queue
weixin_46044420的博客
05-13 1412
使用场景: 有些任务并不需要及时运行，就可以将其写入队列，从而不影响主业务逻辑的进程。 如：此篇博文发布成功后推送消息给其关注的用户。假如粉丝很多，肯定不能将发布博文与推送通知的逻辑捆绑在一起，不然服务器资源卡死。 下面简单介绍如何使用 1.配置队列(config/queue.php) 框架所支持的队列驱动的配置都有。包括：database，Beanstalkd，Amazon SQS，Redis，和一个同步（本地使用）的驱动。还有一个名为 null 的驱动表明不使用队列任务。 ps:这里的队列驱动 可以理解
如何在laravel5 中使用queue队列
热门推荐
homelam的博客
06-12 1万+
如何在laravel5 中使用queue队列 Laravel Queue是延迟处理应用程序中耗时任务的有效方法。此类任务的示例可能包括每当新用户在您的应用程序中注册或通过社交媒体分享帖子时发送验证电子邮件。Laravel队列有助于延迟这些任务，从而提高Web应用程序向您的应用程序的速度。 实例说明 我们将构建一个简单的博客应用程序，允许您提交帖子并在创建新帖子时发送电子邮件。我们将利用队...
laravel 异步队列
06-01
Laravel 异步队列通过将任务放入队列中，异步处理这些任务，以提高应用的性能和稳定性。Laravel 提供了多种队列驱动程序，如 Redis、Beanstalkd、Amazon SQS 等，你可以选择根据实际情况选择适合你的队列驱动。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值