Redis与Queue

Redis有多种数据结构，适合多种不同的应用场景

1. 使用Redis做缓存

Redis的字符串、哈希表两种数据结构适合用来储存大量的键值对信息，从而实现高速缓存。

2. 使用Redis做队列

Redis 有多几种数据结构适于做队列：

• 使用“列表”数据结构，可以实现普通级和优先级队列的功能；

• 使用“ 有序集合”数据结构，可以实现优先级队列；

• 使用“哈希表”数据结构，可以实现延时队列；

3. 使用Redis去重

Redis 有多几种数据结构适于做去重：

• 利用“集合”数据结构，可以实现小批量数据的去重：

• 利用“字符串” 数据结构的位操作，可以实现布隆过滤器，从而实现超大规模的数据去重；

• 利用Redis 自带的HyperLogLog 数据结构，可以实现超大规模数据的去重和计数。

4. 使用Redis实现积分板

Redis 的“ 有序集合”功能可以实现积分板功能，还能实现自动排序、排名功能。

5. 使用Redis实现“发布／订阅”功能

Redis 自带的“发布／订阅”模式可以实现多对多的“ 发布／订阅”功能

Queue和Redis

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

"""
使用python实现一个简单的”生产者/消费者“模型
使用python的queue对象做信息队列
"""


class Producer(Thread):
    """生产者"""

    def __init__(self, queue):
        super().__init__()  # 显示调用父类的初始化方法
        self.queue = queue

    def run(self):
        while True:
            a = random.randint(0, 10)
            b = random.randint(90, 100)
            print(f"生产者产生了两个数字：{a}，{b}")
            self.queue.put((a, b))


class Consumer(Thread):
    """消费者"""

    def __init__(self, queue):
        super().__init__()
        self.queue = queue

    def run(self):
        while True:
            num_tuple = self.queue.get(block=True)
            # block=True 表示 如果队列中为空则阻塞在这里，直到队列中有数据为止
            sum_a_b = sum(num_tuple)
            print(f"消费者消费了一组数据，{num_tuple[0]} + {num_tuple[1]} = {sum_a_b}")
            time.sleep(random.randint(0, 10))


queue = Queue()
producer = Producer(queue)
consumer = Consumer(queue)
producer.start()
consumer.start()
while True:
    time.sleep(1)
# 由于生产过程和消费过程不对等，可能会出现数据生产者的数据堆积在队列中的情况

python中Queue的缺陷，把队列中的数据存放在内存中，如果突然断电，队列中的数据全部消失，缺陷还有很多......

使用Redis替代Queue

生产者

"""
拆分生产者和消费者队列
使用Redis列表作为队列
"""

import time
import json
import redis
import random
from threading import Thread


class Producer(Thread):
    def __init__(self):
        super().__init__()
        self.queue = redis.Redis()

    def run(self) -> None:
        while True:
            a = random.randint(0, 10)
            b = random.randint(90, 100)
            print(f"生产者生产了两个数字:{a},{b}")
            self.queue.rpush("producer", json.dumps((a, b)))
            time.sleep(2)


producer = Producer()
producer.start()
while True:
    time.sleep(1)

消费者

import time
import json
import redis
import random
from threading import Thread


class Consumer(Thread):
    def __init__(self):
        super().__init__()
        self.queue = redis.Redis()

    def run(self) -> None:
        while True:
            num_tuple = self.queue.blpop("producer")
            a, b = json.loads(num_tuple[1].decode())
            print(f"消费者消费了一组数据,{a}+{b}={a+b}")
            time.sleep(random.randint(0,10))


producer = Consumer()
producer.start()
while True:
    time.sleep(1)

• 生产者和消费者可以放在不同的服务器上运行，运行多少消费者都可以
• 可以随时观察reids队列的长度
• Redis对数据会做持久化，也不必担心服务器断电....