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()