- 优先级（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*
#!/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()
======专注高性能web服务器架构和开发=====
https://www.cnblogs.com/chenny7/p/7244913.html
