Redis实现简单消息队列。python+flask+redis实现信息队列。

职责异步化

开拓浏览器,输入地点,按下回车,打开了页面。于是一个HTTP请求(request)就由客户端发送到服务器,服务器处理要,返回响应(response)内容。

咱每天都于浏览网页,发送大大小小的请求让服务器。有时候,服务器收到了请求,会发觉他啊欲让另外的服务器发送请求,或者服务器也待举行另外有工作,于是最初们发送的恳求虽深受死了,也就是要是候服务器就另外的工作。

重新多之上,服务器做的额外事情,并不需要客户端等,这时候就可以把这些额外的作业异步去做。从事异步任务之家伙发出广大。主要原理还是拍卖通报消息,针对通知消息通常采用是行结构。生产以及消费信息进行通信及事务实现。

1.职责异步化#

开辟浏览器,输入地点,按下回车,打开了页面。于是一个HTTP请求(request)就由于客户端发送到服务器,服务器处理要,返回响应(response)内容。

咱们每日还当浏览网页,发送大大小小的请求被服务器。有时候,服务器收到了央,会意识他吧急需让另外的服务器发送请求,或者服务器也需做另外一些政工,于是最初们发送的呼吁虽吃死了,也即是使等服务器就其余的政工。

又多的下,服务器做的附加事情,并不需要客户端等,这时候就足以将这些额外的工作异步去举行。从事异步任务之工具来好多。主要原理还是处理通报消息,针对通知消息通常用是班结构。生产和花信息进行通信以及事情实现。

生消费以及队列

上述异步任务之落实,可以抽象为劳动者消费型。如同一个餐馆,厨师在煮饭,吃货在吃饭。如果厨师做了多,暂时发售不收,厨师便会休息;如果客户多,厨师马不停止蹄的大忙,客户则要逐步等待。实现生产者与买主之法因此很多,下面用Python标准库Queue描绘单稍例子:

import random
import time
from Queue import Queue
from threading import Thread

queue = Queue(10)

class Producer(Thread):
    def run(self):
        while True:
            elem = random.randrange(9)
            queue.put(elem)
            print "厨师 {} 做了 {} 饭 --- 还剩 {} 饭没卖完".format(self.name, elem, queue.qsize())
            time.sleep(random.random())

class Consumer(Thread):
    def run(self):
        while True:
            elem = queue.get()
            print "吃货{} 吃了 {} 饭 --- 还有 {} 饭可以吃".format(self.name, elem, queue.qsize())
            time.sleep(random.random())

def main():
    for i in range(3):
        p = Producer()
        p.start()
    for i in range(2):
        c = Consumer()
        c.start()

if __name__ == '__main__':
    main()

粗粗输出如下:

厨师 Thread-1 做了 1 饭 --- 还剩 1 饭没卖完
厨师 Thread-2 做了 8 饭 --- 还剩 2 饭没卖完
厨师 Thread-3 做了 3 饭 --- 还剩 3 饭没卖完
吃货Thread-4 吃了 1 饭 --- 还有 2 饭可以吃
吃货Thread-5 吃了 8 饭 --- 还有 1 饭可以吃
吃货Thread-4 吃了 3 饭 --- 还有 0 饭可以吃
厨师 Thread-1 做了 0 饭 --- 还剩 1 饭没卖完
厨师 Thread-2 做了 0 饭 --- 还剩 2 饭没卖完
厨师 Thread-1 做了 1 饭 --- 还剩 3 饭没卖完
厨师 Thread-1 做了 1 饭 --- 还剩 4 饭没卖完
吃货Thread-4 吃了 0 饭 --- 还有 3 饭可以吃
厨师 Thread-3 做了 3 饭 --- 还剩 4 饭没卖完
吃货Thread-5 吃了 0 饭 --- 还有 3 饭可以吃
吃货Thread-5 吃了 1 饭 --- 还有 2 饭可以吃
厨师 Thread-2 做了 8 饭 --- 还剩 3 饭没卖完
厨师 Thread-2 做了 8 饭 --- 还剩 4 饭没卖完

2.生消费和队列#

上述异步任务之兑现,可以抽象为劳动者消费型。如同一个饭馆,厨师在煮饭,吃货在进食。如果厨师做了众,暂时发售不了,厨师便见面休息;如果客户多,厨师马不歇蹄的无暇,客户则用逐步等待。实现生产者与消费者之方式因此多,下面采用Python标准库Queue写个稍例子:

import random                                                                                                 
import time
from Queue import Queue
from threading import Thread

queue = Queue(10)

class Producer(Thread):
    def run(self):
        while True:
            elem = random.randrange(9)
            queue.put(elem)
            print "厨师 {} 做了 {} 饭 --- 还剩 {} 饭没卖完".format(self.name, elem, queue.qsize())
            time.sleep(random.random())

class Consumer(Thread):
    def run(self):
        while True:
            elem = queue.get()
            print "吃货{} 吃了 {} 饭 --- 还有 {} 饭可以吃".format(self.name, elem, queue.qsize())
            time.sleep(random.random())

def main():
    for i in range(3):
        p = Producer()
        p.start()
    for i in range(2):
        c = Consumer()
        c.start()

if __name__ == '__main__':
    main()

Redis 队列

Python内置了一个吓用底班结构。我们吧可以是故redis实现类似之操作。并开一个简易的异步任务。

Redis提供了片栽办法来作消息队列。一个凡以生产者消费模式模式,另外一个计就是发布订阅者模式。前者会叫一个要多独客户端监听消息队列,一旦消息到达,消费者及时消费,谁先抢到算谁之,如果队列里没音信,则消费者继续监听。后者也是一个要么多独客户端订阅消息频道,只要发布者发布消息,所有订阅者都能接信息,订阅者都是千篇一律之。

3.Redis 队列#

Python内置了一个好用的排结构。我们啊得以是因此redis实现类似的操作。并召开一个略的异步任务。

Redis提供了点滴种方法来发消息队列。一个凡是运用生产者消费模式模式,另外一个计就是是公布订阅者模式。前者会叫一个还是多独客户端监听消息队列,一旦消息到达,消费者及时消费,谁先赶快到算谁之,如果队列里不曾音信,则消费者继续监听。后者也是一个或者多个客户端订阅消息频道,只要发布者发布信息,所有订阅者都能接收信息,订阅者都是ping的。

生育消费模式(不建议用)

第一运用了redis提供的blpop获取队列数据,如果队列没有多少虽然阻塞等待,也尽管是监听。

import redis

class Task(object):
    def __init__(self):
        self.rcon = redis.StrictRedis(host='localhost', db=5)
        self.queue = 'task:prodcons:queue'

    def listen_task(self):
        while True:
            task = self.rcon.blpop(self.queue, 0)[1]
            print "Task get", task

if __name__ == '__main__':
    print 'listen task queue'
    Task().listen_task()

采取redis的brpop方式召开行,经过一段时间,会发现先后莫名其妙的卡主。也不怕是经过一切ok,redis的lpush也正常,唯独brpop不再消费。该问题格外糟糕复现,但是连过了一段时间就会再现。本人以了高并发,高延迟,弱网络环境相当艺术计算复现都不曾中标,目前照例以寻解决方案。目测依赖redis做brokers的行的celery也遇到相同的问题
,并且其他语言为生近似问题,但是笔者的解决在无适用。猜测问题之来由是redis在拍卖brpop的时刻总是长时未适用会自行假死。后来应用比较low的方案,每当凌晨3沾左右更开一下序列服务。目前安了再度少的idle连接时间(config
set timeout 10),再观察一下是否能够复现。
勿建议以变化环境下该方案。如果下类方案为遇到了问题,并且发生矣解决方案,希望您会联络我哈哈哈。
晋级了 redis 3.2 版本之后,运行了一个基本上月份,目前没有重新起堵塞的问题。

3.1生育消费模式##\

着重用了redis提供的blpop获取队列数据,如果队列没有数量虽然阻塞等待,也即是监听。

import redis                                                                                                  

class Task(object):
    def __init__(self):
        self.rcon = redis.StrictRedis(host='localhost', db=5)
        self.queue = 'task:prodcons:queue'

    def listen_task(self):
        while True:
            task = self.rcon.blpop(self.queue, 0)[1]
            print "Task get", task

if __name__ == '__main__':
    print 'listen task queue'
    Task().listen_task()

颁发订阅模式

使用redis的pubsub功能,订阅者订阅频道,发布者发布消息及频道了,频道就是一个信息队列。

import redis


class Task(object):

    def __init__(self):
        self.rcon = redis.StrictRedis(host='localhost', db=5)
        self.ps = self.rcon.pubsub()
        self.ps.subscribe('task:pubsub:channel')

    def listen_task(self):
        for i in self.ps.listen():
            if i['type'] == 'message':
                print "Task get", i['data']

if __name__ == '__main__':
    print 'listen task channel'
    Task().listen_task()

3.2公布订阅模式##\

动用redis的pubsub功能,订阅者订阅频道,发布者发布消息及频道了,频道就是一个信队列。

import redis                                                                                                                                                                              


class Task(object):

    def __init__(self):
        self.rcon = redis.StrictRedis(host='localhost', db=5)
        self.ps = self.rcon.pubsub()
        self.ps.subscribe('task:pubsub:channel')

    def listen_task(self):
        for i in self.ps.listen():
            if i['type'] == 'message':
                print "Task get", i['data']

if __name__ == '__main__':
    print 'listen task channel'
    Task().listen_task()

Flask 入口

咱分别实现了一定量种植异步任务的后端服务,直接开行他们,就可知监听redis队列或频道的音信了。简单的测试如下:

import redis
import random
import logging
from flask import Flask, redirect

app = Flask(__name__)

rcon = redis.StrictRedis(host='localhost', db=5)
prodcons_queue = 'task:prodcons:queue'
pubsub_channel = 'task:pubsub:channel'

@app.route('/')
def index():

    html = """
<br>
<center><h3>Redis Message Queue</h3>
<br>
<a href="/prodcons">生产消费者模式</a>
<br>
<br>
<a href="/pubsub">发布订阅者模式</a>
</center>
"""
    return html


@app.route('/prodcons')
def prodcons():
    elem = random.randrange(10)
    rcon.lpush(prodcons_queue, elem)
    logging.info("lpush {} -- {}".format(prodcons_queue, elem))
    return redirect('/')

@app.route('/pubsub')
def pubsub():
    ps = rcon.pubsub()
    ps.subscribe(pubsub_channel)
    elem = random.randrange(10)
    rcon.publish(pubsub_channel, elem)
    return redirect('/')

if __name__ == '__main__':
    app.run(debug=True)

起先脚本,使用

siege -c10 -r 5 http://127.0.0.1:5000/prodcons
siege -c10 -r 5 http://127.0.0.1:5000/pubsub

得分别在监听的本子输入被见到异步消息。在异步的职责中,可以履有耗时间的操作,当然目前这些做法并不知道异步的履行结果,如果用理解异步的施行结果,可以考虑设计协程任务还是用有器要RQ或者celery等。

3.3Flask 入口##\

俺们独家实现了区区栽异步任务的后端服务,直接开行他们,就会监听redis队列或频道的音了。简单的测试如下:

import redis
import random
import logging
from flask import Flask, redirect

app = Flask(__name__)

rcon = redis.StrictRedis(host='localhost', db=5)
prodcons_queue = 'task:prodcons:queue'
pubsub_channel = 'task:pubsub:channel'

@app.route('/')
def index():

    html = """
<br>
<center><h3>Redis Message Queue</h3>
<br>
<a href="/prodcons">生产消费者模式</a>
<br>
<br>
<a href="/pubsub">发布订阅者模式</a>
</center>
"""
    return html


@app.route('/prodcons')
def prodcons():
    elem = random.randrange(10)
    rcon.lpush(prodcons_queue, elem)
    logging.info("lpush {} -- {}".format(prodcons_queue, elem))
    return redirect('/')

@app.route('/pubsub')
def pubsub():
    ps = rcon.pubsub()
    ps.subscribe(pubsub_channel)
    elem = random.randrange(10)
    rcon.publish(pubsub_channel, elem)
    return redirect('/')

if __name__ == '__main__':
    app.run(debug=True)  

相关文章