广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 数据库 >Redis和队列的案例分析
  • 634

0
分享到

Redis和队列的案例分析

2024-04-02 19:04:59 634人浏览 八月长安
摘要

这篇文章给大家分享的是有关Redis和队列的案例分析的内容。小编觉得挺实用的，因此分享给大家做个参考。一起跟随小编过来看看吧。概要Redis不仅可作为缓存服务器，还可用作消息队列。它的列表类型天生支持用作消

这篇文章给大家分享的是有关Redis和队列的案例分析的内容。小编觉得挺实用的，因此分享给大家做个参考。一起跟随小编过来看看吧。

概要

Redis不仅可作为缓存服务器，还可用作消息队列。它的列表类型天生支持用作消息队列。如下图所示：

Redis和队列的案例分析

由于Redis的列表是使用双向链表实现的，保存了头尾节点，所以在列表头尾两边插取元素都是非常快的。

普通队列实现

所以可以直接使用Redis的List实现消息队列，只需简单的两个指令lpush和rpop或者rpush和lpop。简单示例如下：

存放消息端(消息生产者):

package org.yamikaze.redis.messsage.queue; 
import org.yamikaze.redis.test.MyJedisFactory;import redis.clients.jedis.Jedis; 
import java.util.concurrent.TimeUnit; 
public class Producer extends Thread { 
    public static final String MESSAGE_KEY = "message:queue";    private Jedis jedis;    private String producerName;    private volatile int count; 
    public Producer(String name) {        this.producerName = name;
        init();
    } 
    private void init() {
        jedis = MyJedisFactory.getLocalJedis();
    } 
    public void putMessage(String message) {
        Long size = jedis.lpush(MESSAGE_KEY, message);
        System.out.println(producerName + ": 当前未被处理消息条数为:" + size);
        count++;
    } 
    public int getCount() {        return count;
    }
 
    @Override    public void run() {        try {            while (true) {
                putMessage(StringUtils.generate32Str());
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (InterruptedException e) {
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    } 
    public static void main(String[] args) throws InterruptedException{
        Producer producer = new Producer("myProducer");
        producer.start(); 
        for(; ;) {
            System.out.println("main : 已存储消息条数:" + producer.getCount());
            TimeUnit.SECONDS.sleep(10);
        }
    }
}

消息处理端(消息消费者):

package org.yamikaze.redis.messsage.queue; 
import org.yamikaze.redis.test.MyJedisFactory;import redis.clients.jedis.Jedis; 
public class Customer extends Thread{ 
    private String customerName;    private volatile int count;    private Jedis jedis; 
    public Customer(String name) {        this.customerName = name;
        init();
    } 
    private void init() {
        jedis = MyJedisFactory.getLocalJedis();
    } 
    public void proceSSMessage() {
        String message = jedis.rpop(Producer.MESSAGE_KEY);        if(message != null) {
            count++;
            handle(message);
        }
    } 
    public void handle(String message) {
        System.out.println(customerName + " 正在处理消息,消息内容是: " + message + " 这是第" + count + "条");
    }
 
    @Override    public void run() {        while (true) {
            processMessage();
        }
    } 
    public static void main(String[] args) {
        Customer customer = new Customer("yamikaze");
        customer.start();
    }
}

貌似还不错，但上述例子中消息消费者有一个问题存在，即需要不停的调用rpop方法查看List中是否有待处理消息。每调用一次都会发起一次连接，这会造成不必要的浪费。也许你会使用Thread.sleep()等方法让消费者线程隔一段时间再消费，但这样做有两个问题：

1）、如果生产者速度大于消费者消费速度，消息队列长度会一直增大，时间久了会占用大量内存空间。

2）、如果睡眠时间过长，这样不能处理一些时效性的消息，睡眠时间过短，也会在连接上造成比较大的开销。

所以可以使用brpop指令，这个指令只有在有元素时才返回，没有则会阻塞直到超时返回null，于是消费端可以将processMessage可以改为这样：

public void processMessage() {    
    List<String> messages = jedis.brpop(0, Producer.MESSAGE_KEY, "tesTKEy");    if(messages.size() != 0) {        //由于该指令可以监听多个Key,所以返回的是一个列表        //列表由2项组成，1) 列表名，2)数据
        String keyName = messages.get(0);        //如果返回的是MESSAGE_KEY的消息
        if(Producer.MESSAGE_KEY.equals(keyName)) {
            String message = messages.get(1);
            handle(message);
        }
 
    }
    System.out.println("=======================");
}

然后可以运行Customer，清空控制台，可以看到程序没有任何输出，阻塞在了brpop这儿。然后在打开Redis的客户端，输入指令client list，可以查看当前有两个连接。

一次生产多次消费的队列

Redis除了对消息队列提供支持外，还提供了一组命令用于支持发布/订阅模式。利用Redis的pub/sub模式可以实现一次生产多次消费的队列。

1)发布
   PUBLISH指令可用于发布一条消息，格式 PUBLISH channel message

返回值表示订阅了该消息的数量。
   2)订阅
   SUBSCRIBE指令用于接收一条消息，格式 SUBSCRIBE channel

可以看到使用SUBSCRIBE指令后进入了订阅模式，但没有接收到publish发送的消息，这是因为只有在消息发出去前订阅才会接收到。在这个模式下其他指令，只能看到回复。回复分为三种类型：
   1、如果为subscribe，第二个值表示订阅的频道，第三个值表示是第几个订阅的频道?(理解成序号?)
   2、如果为message(消息)，第二个值为产生该消息的频道，第三个值为消息
   3、如果为unsubscribe，第二个值表示取消订阅的频道，第三个值表示当前客户端的订阅数量。

可以使用指令UNSUBSCRIBE退订，如果不加参数，则会退订所有由SUBSCRIBE指令订阅的频道。
 
   Redis还支持基于通配符的消息订阅，使用指令PSUBSCRIBE (pattern subscribe)，例如：

再试试推送消息会得到以下结果：

可以看到publish指令返回的是2，而订阅端这边接收了两次消息。这是因为PSUBSCRIBE指令可以重复订阅频道。而使用PSUBSCRIBE指令订阅的频道也要使用指令PUNSUBSCRIBE指令退订，该指令无法退订SUBSCRIBE订阅的频道，同理UNSUBSCRIBE也不能退订PSUBSCRIBE指令订阅的频道。同时PUNSUBSCRIBE指令通配符不会展开。
例如：PUNSUBSCRIBE * 不会匹配到 channel.*, 所以要取消订阅channel.*就要这样写PUBSUBSCRIBE channel.*。

代码示范如下：

package org.yamikaze.redis.messsage.subscribe; 
import org.yamikaze.redis.messsage.queue.StringUtils;import org.yamikaze.redis.test.MyJedisFactory;import redis.clients.jedis.Jedis; 
public class Publisher { 
    public static final String CHANNEL_KEY = "channel:message";    private Jedis jedis; 
    public Publisher() {
        jedis = MyJedisFactory.getLocalJedis();
    } 
    public void publishMessage(String message) {        if(StringUtils.isBlank(message)) {            return;
        }
        jedis.publish(CHANNEL_KEY, message);
    } 
    public static void main(String[] args) {
        Publisher publisher = new Publisher();
        publisher.publishMessage("Hello Redis!");
    }
}

简单的发送一个消息。

消息订阅方：

package org.yamikaze.redis.messsage.subscribe; 
import org.yamikaze.redis.test.MyJedisFactory;import redis.clients.jedis.Jedis;import redis.clients.jedis.JedisPubSub; 
import java.util.concurrent.TimeUnit; 
public class SubscribeClient { 
    private Jedis jedis;    private static final String EXIT_COMMAND = "exit"; 
    public SubscribeClient() {
        jedis = MyJedisFactory.getLocalJedis();
    } 
    public void subscribe(String ...channel) {        if(channel == null || channel.length <= 0) {            return;
        }        //消息处理,接收到消息时如何处理
        JedisPubSub jps = new JedisPubSub() {            
            @Override            public void onMessage(String channel, String message) {                if(Publisher.CHANNEL_KEY.equals(channel)) {
                    System.out.println("接收到消息: channel : " + message);                    //接收到exit消息后退出
                    if(EXIT_COMMAND.equals(message)) {
                        System.exit(0);
                    }
 
                }
            } 
            
            @Override            public void onSubscribe(String channel, int subscribedChannels) {                if(Publisher.CHANNEL_KEY.equals(channel)) {
                    System.out.println("订阅了频道:" + channel);
                }
            }
        };        //可以订阅多个频道 当前线程会阻塞在这儿        jedis.subscribe(jps, channel);
    } 
    public static void main(String[] args) {
        SubscribeClient client = new SubscribeClient();
        client.subscribe(Publisher.CHANNEL_KEY);        //并没有 unsubscribe方法        //相应的也没有punsubscribe方法    }
}

先运行client，再运行Publisher进行消息发送，输出结果：

Redis和队列的案例分析

Redis的pub/sub也有其缺点，那就是如果消费者下线，生产者的消息会丢失。

延时队列

背景

在业务发展过程中，会出现一些需要延时处理的场景，比如：

a.订单下单之后超过30分钟用户未支付，需要取消订单
b.订单一些评论，如果48h用户未对商家评论，系统会自动产生一条默认评论
c.点我达订单下单后，超过一定时间订单未派出，需要超时取消订单等。。。
处理这类需求，比较直接简单的方式就是定时任务轮训扫表。这种处理方式在数据量不大的场景下是完全没问题，但是当数据量大的时候高频的轮训数据库就会比较的耗资源，导致数据库的慢查或者查询超时。所以在处理这类需求时候，采用了延时队列来完成。

几种延时队列

延时队列就是一种带有延迟功能的消息队列。下面会介绍几种目前已有的延时队列：

1.Java中java.util.concurrent.DelayQueue

优点：jdk自身实现，使用方便，量小适用
缺点：队列消息处于JVM内存，不支持分布式运行和消息持久化

2.RocketMQ延时队列

优点：消息持久化，分布式
缺点：不支持任意时间精度，只支持特定level的延时消息

3.RabbitMQ延时队列（TTL+DLX实现）

优点：消息持久化，分布式
缺点：延时相同的消息必须扔在同一个队列

Redis实现的延时消息队列适合的项目特点：

  • spring框架管理对象
  • 有消息需求，但不想维护MQ中间件
  • 有使用redis
  • 对消息持久化并没有很苛刻的要求

Redis实现的延时消息队列思路

Redis由于其自身的Zset数据结构，本质就是Set结构上加了个排序的功能，除了添加数据value之外，还提供另一属性score，这一属性在添加修改元素时候可以指定，每次指定后，Zset会自动重新按新的值调整顺序。可以理解为有两列字段的数据表，一列存value,一列存顺序编号。操作中key理解为zset的名字，那么对延时队列又有何用呢？

试想如果score代表的是想要执行时间的时间戳，在某个时间将它插入Zset集合中，它变会按照时间戳大小进行排序，也就是对执行时间前后进行排序，这样的话，起一个死循环线程不断地进行取第一个key值，如果当前时间戳大于等于该key值的socre就将它取出来进行消费删除，就可以达到延时执行的目的, 注意不需要遍历整个Zset集合，以免造成性能浪费。

Zset的排列效果如下图：

Redis和队列的案例分析

java代码实现如下：

package cn.chinotan.service.delayQueueRedis;import org.apache.commons.lang3.StringUtils;import redis.clients.jedis.Jedis;import redis.clients.jedis.JedisPool;import redis.clients.jedis.Tuple;import java.text.SimpleDateFORMat;import java.util.Calendar;import java.util.Date;import java.util.Set;import java.util.concurrent.CountDownLatch;import java.util.concurrent.TimeUnit;public class AppTest {    private static final String ADDR = "127.0.0.1";    private static final int PORT = 6379;    private static JedisPool jedisPool = new JedisPool(ADDR, PORT);    private static CountDownLatch cdl = new CountDownLatch(10);    public static Jedis getJedis() {        return jedisPool.getResource();
    }    
    public void productionDelayMessage() {        for (int i = 0; i < 5; i++) {
            Calendar instance = Calendar.getInstance();            // 3秒后执行
            instance.add(Calendar.SECOND, 3 + i);
            AppTest.getJedis().zadd("orderId", (instance.getTimeInMillis()) / 1000, StringUtils.join("000000000", i + 1));
            System.out.println("生产订单: " + StringUtils.join("000000000", i + 1) + " 当前时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println((3 + i) + "秒后执行");
        }
    }    //消费者，取订单
    public static void consumerDelayMessage() {
        Jedis jedis = AppTest.getJedis();        while (true) {
            Set<Tuple> order = jedis.zrangeWithScores("orderId", 0, 0);            if (order == null || order.isEmpty()) {
                System.out.println("当前没有等待的任务");                try {
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }                continue;
            }
            Tuple tuple = (Tuple) order.toArray()[0];            double score = tuple.getScore();
            Calendar instance = Calendar.getInstance();            long nowTime = instance.getTimeInMillis() / 1000;            if (nowTime >= score) {
                String element = tuple.getElement();
                Long orderId = jedis.zrem("orderId", element);                if (orderId > 0) {
                    System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + ":redis消费了一个任务：消费的订单OrderId为" + element);
                }
            }
        }
    }    static class DelayMessage implements Runnable{
        @Override        public void run() {            try {
                cdl.await();
                consumerDelayMessage();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }    
    public static void main(String[] args) {
        AppTest appTest = new AppTest();
        appTest.productionDelayMessage();        for (int i = 0; i < 10; i++) {            new Thread(new DelayMessage()).start();
            cdl.countDown();
        }
    }
}

实现效果如下：

Redis和队列的案例分析

感谢各位的阅读！关于Redis和队列的案例分析就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到吧！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Redis和队列的案例分析

本文链接: https://www.lsjlt.com/news/50456.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • Redis和队列的案例分析
    这篇文章给大家分享的是有关Redis和队列的案例分析的内容。小编觉得挺实用的，因此分享给大家做个参考。一起跟随小编过来看看吧。概要Redis不仅可作为缓存服务器，还可用作消息队列。它的列表类型天生支持用作消...
    99+
    2022-10-18
  • Java的栈和队列实例分析
    这篇文章主要讲解了“Java的栈和队列实例分析”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java的栈和队列实例分析”吧！栈package com.yuzhenc.collect...
    99+
    2023-06-29
  • Python的队列实例分析
    这篇“Python的队列实例分析”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Python的队列实例分析”文章吧。模拟打印机...
    99+
    2023-06-29
  • php中队列的示例分析
    小编给大家分享一下php中队列的示例分析，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！什么是队列？相对于栈来说，队列是一种先进先出（FIFO）的顺序逻辑结构。什么...
    99+
    2023-06-20
  • redis系列：通过队列案例学习list命令
    前言这一篇文章将讲述Redis中的list类型命令，同样也是通过demo来讲述，其他部分这里就不在赘述了。项目Github地址：https://github.com/rainbowda/learnWay/tree/master/learnR...
    99+
    2023-06-04
  • Redis实现分布式队列浅析
    Redis是什么？ Redis是一个简单的，高效的，分布式的，基于内存的缓存工具。 假设好服务器后，通过网络连接（类似数据库），提供Key－Value式缓存服务。 简单，是Redis突出的特色。 简...
    99+
    2022-06-04
    队列 分布式 Redis
  • python中队列基本操作和多线程队列的示例分析
    这篇文章给大家分享的是有关python中队列基本操作和多线程队列的示例分析的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。一、队列基本操作from queue import Queue...
    99+
    2023-06-29
  • Oracle高级队列的示例分析
    小编给大家分享一下Oracle高级队列的示例分析，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！Oracle高级队列(Advanc...
    99+
    2022-10-18
  • php双向队列的实例分析
    php双向队列的实例分析，很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。双向队列是指一种具有队列和栈的性质的数据结构。双向队列中的元素可以从两端弹出，其限定插入和...
    99+
    2023-06-25
  • Javascript队列方法实例分析
    这篇文章主要介绍“Javascript队列方法实例分析”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Javascript队列方法实例分析”文章能帮助大家解决问题。J...
    99+
    2022-10-19
  • C语言中队列的示例分析
    这篇文章将为大家详细讲解有关C语言中队列的示例分析，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。一、队列（Queue）0x00 队列的概念 概念：① 队列只允许在一端进行插入数据操作，在另一端进...
    99+
    2023-06-29
  • python列表案例分析
    本篇内容主要讲解“python列表案例分析”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“python列表案例分析”吧!下面要学的是列表：任务1、“千年虫”我来了函数enumerateenumer...
    99+
    2023-06-29
  • JavaScript单线程和任务队列的示例分析
    这篇文章给大家分享的是有关JavaScript单线程和任务队列的示例分析的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。一、JavaScript为什么设计为单线程？JavaScri...
    99+
    2022-10-19
  • redis比mysql快的案例分析
    这篇文章给大家分享的是有关redis比mysql快的案例分析的内容。小编觉得挺实用的，因此分享给大家做个参考。一起跟随小编过来看看吧。Redis将所有数据放在内存中，非数据同步正常工作中，是不需要从磁盘读取...
    99+
    2022-10-18
  • Redis延迟队列和分布式延迟队列的简答实现
            最近，又重新学习了下Redis，Redis不仅能快还能慢，简直利器，今天就为大家介绍一下Redi...
    99+
    2022-11-12
  • SpringBoot整合Redis案例分析
    这篇文章主要介绍了SpringBoot整合Redis案例分析的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇SpringBoot整合Redis案例分析文章都会有所收获，下面我们一起来看看吧。Springboot整...
    99+
    2023-06-19
  • Redis压缩列表的示例分析
    这篇文章主要介绍了Redis压缩列表的示例分析，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获。下面让小编带着大家一起了解一下。此篇文章是主要介绍Redis在数据存储方面的其中一种...
    99+
    2022-10-18
  • redis之List操作的案例分析
    小编给大家分享一下redis之List操作的案例分析，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！List操作，redis中的L...
    99+
    2022-10-18
  • redis集群方案的示例分析
    这篇文章主要为大家展示了“redis集群方案的示例分析”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“redis集群方案的示例分析”这篇文章吧。一、主从模式将数据...
    99+
    2022-10-19
  • JavaScript数据结构之优先队列与循环队列的示例分析
    这篇文章将为大家详细讲解有关JavaScript数据结构之优先队列与循环队列的示例分析，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。具体如下：优先队列实现一个优先队列：设...
    99+
    2022-10-19
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作