laravel的消息队列剖析
这篇来自于看到朋友转的58沈剑的一篇文章：1分钟实现“延迟消息”功能
在实际工作中也不止遇见过一次这个问题，我在想着以前是怎么处理的呢？我记得当初在上家公司的时候直接使用的是laravel的queue来实现的。当然，这里说的laravel的queue实际上也是基于redis的队列实现的。正好今天遇上这个问题，追下底层机制。
使用如下：http://d.laravel-china.org/docs/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);
// IlluminateContractsBusDispatcher
首先需要理解这里的Dispatcher::class 实际注入的是哪个类。
看到vendor/laravel/framework/src/Illuminate/Bus/BusServiceProvider.php:26，有
public function register()
{
$this->app->singleton('IlluminateBusDispatcher', function ($app) {
return new Dispatcher($app, function ($connection = null) use ($app) {
return $app['IlluminateContractsQueueFactory']->connection($connection);
});
});
$this->app->alias(
'IlluminateBusDispatcher', 'IlluminateContractsBusDispatcher'
);
$this->app->alias(
'IlluminateBusDispatcher', 'IlluminateContractsBusQueueingDispatcher'
);
}
所以最后是实例化了IlluminateBusDispatcher
看看它的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 EventsJobProcessing(
$connectionName, $job
));
这里的raiseBeforeJobEvent和raiseAfterJobEvent又是使用event和listener的形式来做处理的。这里的$this->events是vendor/laravel/framework/src/Illuminate/Events/Dispatcher.php:197
这里就是触发了一个EventsJobProcessing事件，我们现在要找到对应的lister：
答案是在QueueManager中定义的
/**
* Register an event listener for the before job event.
*
* @param mixed $callback
* @return void
*/
public function before($callback)
{
$this->app['events']->listen(EventsJobProcessing::class, $callback);
}
/**
* Register an event listener for the after job event.
*
* @param mixed $callback
* @return void
*/
public function after($callback)
{
$this->app['events']->listen(EventsJobProcessed::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])
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" "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])
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" "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])
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}" "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等操作。也是防止了锁的使用把。每一步操作失败了，都会有后续的步骤继续帮忙完成，记录等行为的。