一种消息和任务队列——beanstalkd

beanstalkd 是一个轻量级消息中间件，其主要特性：

• 基于管道  (tube) 和任务 (job) 的工作队列 (work-queue)：d
  　　管道（tube），tube类似于消息主题（topic），在一个beanstalkd中可以支持多个tube，每个tube都有自己的producer和consumer；
        任务（job），beanstalkd用job代替了message的概念，与消息不同，job有一系列状态： 
• 内部实现采用了 libevent, 服务器-客户端之间用类似 memcached 的轻量级通讯协议，具有有很高的性能。
• 尽管是内存队列，beanstalkd 提供了 binlog 机制，当重启 beanstalkd 时，当前任务状态能够从纪录的本地 binlog 中恢复。

• 优先级（priority）：job可以有0~2^32个优先级，0代表最高优先级，beanstalkd使用最大最小堆处理job的优先级排序，因此reserve命令的时间复杂度是O(logN)；
• 延时（delay），有两种方式可以执行延时任务：producer发布任务时指定延时；或者当任务处理完毕后, consumer再次将任务放入队列延时执行 (RELEASE with <delay>)；
• 超时重发（time-to-run），Beanstalkd 把job返回给consumer以后：consumer必须在预设的 TTR (time-to-run) 时间内发送 delete / release/ bury 改变任务状态；否则 Beanstalkd 会认为消息处理失败，然后把job交给另外的消费者节点执行。如果consumer预计在 TTR (time-to-run) 时间内无法完成任务, 也可以发送 touch 命令, 它的作用是让 Beanstalkd 从系统时间重新计算 TTR ；
• 任务预留（buried），如果job因为某些原因无法执行, consumer可以把任务置为 buried 状态让 Beanstalkd 保留这些任务。管理员可以通过 peek buried 命令查询被保留的任务，并且进行人工干预。简单的, kick <n> 能够一次性把 n 条被保留的任务踢回队列。

 

 

 

 

job的状态

• READY，需要立即处理的任务，当延时 (DELAYED) 任务到期后会自动成为当前任务；
• DELAYED，延迟执行的任务, 当消费者处理任务后，可以用将消息再次放回 DELAYED 队列延迟执行；
• RESERVED，已经被消费者获取, 正在执行的任务，Beanstalkd 负责检查任务是否在 TTR(time-to-run) 内完成；
• BURIED，保留的任务: 任务不会被执行，也不会消失，除非有人把它 "踢" 回队列；
• DELETED，消息被彻底删除。Beanstalkd 不再维持这些消息。

 

如下，是一个典型任务的生命周期：

producer执行put命令将job放入队列，consumer执行reserve命令从队列取出job，执行完毕后发送delete命令告诉beanstalkd删除该job。

如果没有执行delete命令，beanstalkd将在一个TTR周期（默认120s）后重新将该job加入队列；

 

 put            reserve               delete
  -----> [READY] ---------> [RESERVED] --------> *poof*

 

下面是一个使用beanstalkc（python客户端）操作beanstalkd的例子：

#!/usr/bin/env python
import beanstalkc

beanstalk=beanstalkc.Connection(host="127.0.0.1",port=11300)

# pruducer
beanstalk.put('hello')
beanstalk.put('world')

# consumer
job1=beanstalk.reserve()
print "job1: " + job1.body
job1.delete()

job2=beanstalk.reserve(timeout=1)
print "job2: " + job2.body
job2.delete()

job3=beanstalk.reserve(timeout=1)       # Error，队列中已经没有job了
print "job3: " + job3.body
job3.delete()

 

tube的管理

beanstalkd通过tube维护多个队列，每个tube都是一个独立的queue，可以使用use命令切换tube，如果切换的tube不存在，会自动创建一个：

print beanstalk.tubes()     # default
print beanstalk.using()     # default 

beanstalk.use('queue1')
print beanstalk.using()     # queue1

beanstalk.use('queue2')     # queue2
print beanstalk.using()

print beanstalk.tubes()     # default, queue2

如上面的例子，在最后的tubes()命令打印所有tube的时候，并没有看到queue1，这是因为没有任何client 在using或者watching的tube会自动消失。

可以使用watch命令让client同时处理多个tube，而不用担心tube会被销毁：

print beanstalk.tubes()     # default
print beanstalk.using()     # default

beanstalk.use('queue1')
beanstalk.watch('queue1')
print beanstalk.using()     # queue1

beanstalk.use('queue2')     # queue2
print beanstalk.using()

print beanstalk.tubes()     # default, queue1, queue2
print beanstalk.watching()  # default, queue1

watch的tube如果不存在，会被自动创建，可以用ignore命令取消关注tube：

beanstalk.watch('queue3')
print beanstalk.watching()  # default, queue3
beanstalk.ignore('queue3')
print beanstalk.watching()  # default

注意，watch和use是两个独立的动作，use一个tube不代表watching它了，反之watch一个tube也不代表using它；

 

 

 

beanstalkc命令

如下，是一个job更完整的状态变迁和生命周期：

 

put with delay               release with delay
  ----------------> [DELAYED] <------------.
                        |                   |
                        | (time passes)     |
                        |                   |
   put                  v     reserve       |       delete
  -----------------> [READY] ---------> [RESERVED] --------> *poof*
                       ^  ^                |  |
                       |     release      |  |
                       |    `-------------'   |
                       |                      |
                       | kick                 |
                       |                      |
                       |       bury           |
                    [BURIED] <---------------'
                       |
                       |  delete
                        `--------> *poof*

 

一些例子：

put的时候加上delay参数，可以延迟发布job：

# pruducer
beanstalk.put('hello', delay=10)
beanstalk.put('world')

# consumer
job1=beanstalk.reserve()
print "job1: " + job1.body  # World
job1.delete()

job2=beanstalk.reserve(timeout=0) 
print "job2: " + job2.body  # Error,

put命令也支持优先级参数：

# pruducer
beanstalk.put('hello', priority=10)
beanstalk.put('world', priority=9)

# consumer
job1=beanstalk.reserve()
print "job1: " + job1.body  # world
job1.delete()

job2=beanstalk.reserve(timeout=0) 
print "job2: " + job2.body  # hello
job2.delete()

release命令可以释放job回队列：

# pruducer
beanstalk.put('hello') 
beanstalk.put('world')

# consumer
job1=beanstalk.reserve()
print "job1: " + job1.body  # hello
job1.release()

job2=beanstalk.reserve(timeout=0) 
print "job2: " + job2.body  # hello

 bury命令将job放到一个特殊的FIFO队列中，之后不能被reserve命令获取，但可以用kick命令扔回工作队列中，之后就能被消费了：

# pruducer
beanstalk.put('hello')
beanstalk.put('world')

# consumer
job1=beanstalk.reserve(timeout=0)
job1.bury()
print job1.stats()['state'] # buried

job2=beanstalk.reserve(timeout=0)
print "job2: " + job2.body  # world
job2.delete()

beanstalk.kick()

job3=beanstalk.reserve(timeout=0)
print "job3: " + job3.body  # hello
job3.delete()

peek命令允许查看一个job，但不会reserve它；

# pruducer
beanstalk.put('hello')
beanstalk.put('world')

#print(beanstalk.stats())  

# consumer
job1=beanstalk.reserve(timeout=0)
job1_id=job1.stats()['id'] 
print job1_id
job1_r=beanstalk.peek(job1_id)
print "job1 " + job1_r.body  # hello

job2=beanstalk.reserve(timeout=0)
print "job2: " + job2.body  # hello
job2.delete()

job3=beanstalk.reserve(timeout=0) 
print "job3: " + job3.body  # world
job3.delete()