redis能否做数据库用取决于如下几个条件： (推荐学习：Redis视频教程)
 
1：数据量，毕竟内存数据库，还是受限于内存的容量，虽然可以redis可以持久化。
 
2：数据的结构，是否能够将关系型数据结构都转换为key/value的形式。
 
3：查询的效率，对范围查询等，是否能转换为高效的hash索引查询
 
redis能不能拿来当数据库，取决于你想要存储什么数据：
 
如果你打算存储一些临时数据，数据规模不大，不需要太复杂的查询，但是对性能的要求比较高，那可以拿redis当数据库使用，否则别拿来当数据库用。
 
1. 像上面提到的，redis的持久化有问题，如果使用aof模式，并且fsync always，则性能比mysql 还低，如果你喜欢redis 方便的数据结构而对性能要求不高，或者性能要求很高，但允许一定程度的丢失数据，则可以用redis做为数据库。
 
2.redis 是内存数据库， 内存写满后，数据不会存储到硬盘上(VM 不稳定，diskstore未启用)，如果你内存足够大，则可以用redis作为数据库。
 
redis是一种k/v的内存数据库，适合小数据量的存储以及实时要求高的地方，但是不适合做完整数据库，完整数据库基本上都有一套详细解决方案，基本上没有做了的，比如mysql。
 
项目里用到的redis是用来做缓存的，设置过期时间，到时就自动清掉。数据库还是用mysql等这种成熟的方案。
 
如果你非要用一种nosql来做数据库，推荐你用Mongodb。
 
这种KV存储完全不具备数据库所能提供的数据安全性保障。
 
所以还是用来做缓存比较合适。
 
redis做数据库不靠谱，不是所有的数据都是立即回写磁盘的。

 
文章目录
 
1 引言
1.1 Redis中List队列
1.1.1 简单使用
1.1.2 解决cpu空转问题
1.1.3 Redis阻塞式拉取
   
1.2 Redis发布订阅
1.2.1 简单使用
1.2.2 发布订阅的缺点
   
1.3 Redis中的Stream
1.3.1 简单使用
1.3.2 stream阻塞拉取
1.3.3 Stream支持发布 / 订阅模式
1.3.4 stream不丢消息
1.3.5 stream持久化处理
1.3.6 stream消息堆积
   
1.4 与专业消息对比
1.4.1 生产者会不会丢消息
1.4.2 消费者会不会丢消息
1.4.3 队列中间件会不会丢消息
1.4.4 消息积压怎么办
  
 


 本文转载于：
https://mp.weixin.qq.com/s/uhMrqR__6qgpl7vrE_otTQ
 
1 引言
 
我经常听到很多人讨论，关于把 Redis 当作队列来用是否合适的问题。
 有些人表示赞成，他们认为 Redis 很轻量，用作队列很方便。
 也些人则反对，认为 Redis 会丢数据，最好还是用专业的队列中间件更稳妥
 
究竟哪种方案更好呢？
 这篇文章，就聊一聊把 Redis 当作队列，究竟是否合适这个问题。
 从简单到复杂，一步步梳理其中的细节，把这个问题真正的讲清楚。
 看完这篇文章后对这个问题你会有全新的认识。
 在文章的最后，还会告诉你关于技术选型的思路，文章有点长，希望你可以耐心读完
 
1.1 Redis中List队列
 
1.1.1 简单使用
 
从最简单的开始：List 队列
 首先，我们先从最简单的场景开始讲起
 如果你的业务需求足够简单，想把 Redis 当作队列来使用，肯定最先想到的就是使用 List 这个数据类型
 因为List底层的实现就是一个链表，在头部和尾部操作元素，时间复杂度都是 O(1)，这意味着它非常符合消息队列的模型。
 
如果把 List 当作队列，你可以这么来用。
 
生产者使用 LPUSH 发布消息：
 
127.0.0.1:6379> LPUSH queue msg1
(integer) 1
127.0.0.1:6379> LPUSH queue msg2
(integer) 2
 
消费者这一侧，使用 RPOP 拉取消息：
 
127.0.0.1:6379> RPOP queue
"msg1"
127.0.0.1:6379> RPOP queue
"msg2"
 
这个模型非常简单，也很容易理解。
 
 但这里有个小问题，当队列中已经没有消息了，消费者在执行 RPOP 时，会返回 NULL
 
127.0.0.1:6379> RPOP queue
(nil)   // 没消息了
 
而我们在编写消费者逻辑时，一般是一个死循环，这个逻辑需要不断地从队列中拉取消息进行处理，伪代码一般会这么写：
 
while true:
    msg = redis.rpop("queue")
    // 没有消息，继续循环
    if msg == null:
        continue
    // 处理消息
    handle(msg)
 
如果此时队列为空，那消费者依旧会频繁拉取消息，这会造成CPU 空转，不仅浪费 CPU 资源，还会对 Redis 造成压力。
 
1.1.2 解决cpu空转问题
 
怎么解决这个问题呢？
 也很简单，当队列为空时，我们可以休眠一会，再去尝试拉取消息。代码可以修改成这样：
 
while true:
    msg = redis.rpop("queue")
    // 没有消息，休眠2s
    if msg == null:
        sleep(2)
        continue
    // 处理消息        
    handle(msg)
 
这就解决了 CPU 空转问题
 这个问题虽然解决了，但又带来另外一个问题：当消费者在休眠等待时，有新消息来了，那消费者处理新消息就会存在延迟
 假设设置的休眠时间是 2s，那新消息最多存在 2s 的延迟。
 
1.1.3 Redis阻塞式拉取
 
要想缩短这个延迟，只能减小休眠的时间。但休眠时间越小，又有可能引发 CPU 空转问题。
 鱼和熊掌不可兼得
 那如何做，既能及时处理新消息，还能避免 CPU 空转呢？
 Redis 是否存在这样一种机制：如果队列为空，消费者在拉取消息时就阻塞等待，一旦有新消息过来，就通知我的消费者立即处理新消息呢？
 幸运的是，Redis 确实提供了「阻塞式」拉取消息的命令：BRPOP / BLPOP，这里的 B 指的是阻塞Block
 
 
现在，你可以这样来拉取消息了：
 
while true:
    // 没消息阻塞等待，0表示不设置超时时间
    msg = redis.brpop("queue", 0)
    if msg == null:
        continue
    // 处理消息
    handle(msg)
 
使用 BRPOP 这种阻塞式方式拉取消息时，还支持传入一个超时时间，如果设置为 0，则表示不设置超时，直到有新消息才返回，否则会在指定的超时时间后返回 NULL
 这个方案不错，既兼顾了效率，还避免了 CPU 空转问题，一举两得
 
注意：如果设置的超时时间太长，这个连接太久没有活跃过，可能会被 Redis Server 判定为无效连接，之后 Redis Server 会强制把这个客户端踢下线。所以，采用这种方案，客户端要有重连机制。
 
解决了消息处理不及时的问题，你可以再思考一下，这种队列模型，有什么缺点？
 
不支持重复消费：消费者拉取消息后，这条消息就从 List 中删除了，无法被其它消费者再次消费，即不支持多个消费者消费同一批数据
消息丢失：消费者拉取到消息后，如果发生异常宕机，那这条消息就丢失了
 
第一个问题是功能上的，使用 List 做消息队列，它仅仅支持最简单的，一组生产者对应一组消费者，不能满足多组生产者和消费者的业务场景
 第二个问题就比较棘手了，因为从 List 中 POP 一条消息出来后，这条消息就会立即从链表中删除了。也就是说，无论消费者是否处理成功，这条消息都没办法再次消费了。这也意味着，如果消费者在处理消息时异常宕机，那这条消息就相当于丢失了。
 
1.2 Redis发布订阅
 
1.2.1 简单使用
 
发布/订阅模型：Pub/Sub
 从名字就能看出来，这个模块是 Redis 专门是针对发布/订阅这种队列模型设计的
 它正好可以解决前面提到的第一个问题：重复消费。
 即多组生产者、消费者的场景，我们来看它是如何做的。
 Redis 提供了 PUBLISH / SUBSCRIBE 命令，来完成发布、订阅的操作。
 
 假设你想开启 2 个消费者，同时消费同一批数据，就可以按照以下方式来实现。
 首先，使用 SUBSCRIBE 命令，启动 2 个消费者，并订阅同一个队列。
 
// 2个消费者 都订阅一个队列
127.0.0.1:6379> SUBSCRIBE queue
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "queue"
3) (integer) 1
 
此时，2 个消费者都会被阻塞住，等待新消息的到来。
 之后，再启动一个生产者，发布一条消息。
 
127.0.0.1:6379> PUBLISH queue msg1
(integer) 1
 
这时，2 个消费者就会解除阻塞，收到生产者发来的新消息。
 
127.0.0.1:6379> SUBSCRIBE queue
// 收到新消息
1) "message"
2) "queue"
3) "msg1"
 
看到了么，使用 Pub/Sub 这种方案，既支持阻塞式拉取消息，还很好地满足了多组消费者，消费同一批数据的业务需求。
 除此之外，Pub/Sub 还提供了匹配订阅模式，允许消费者根据一定规则，订阅多个自己感兴趣的队列
 
// 订阅符合规则的队列
127.0.0.1:6379> PSUBSCRIBE queue.*
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "queue.*"
3) (integer) 1
 
这里的消费者，订阅了 queue.*相关的队列消息。
 之后，生产者分别向 queue.p1 和 queue.p2 发布消息。
 
127.0.0.1:6379> PUBLISH queue.p1 msg1
(integer) 1
127.0.0.1:6379> PUBLISH queue.p2 msg2
(integer) 1
 
这时再看消费者，它就可以接收到这 2 个生产者的消息了。
 
127.0.0.1:6379> PSUBSCRIBE queue.*
Reading messages... (press Ctrl-C to quit)
...
// 来自queue.p1的消息
1) "pmessage"
2) "queue.*"
3) "queue.p1"
4) "msg1"

// 来自queue.p2的消息
1) "pmessage"
2) "queue.*"
3) "queue.p2"
4) "msg2"
 

 我们可以看到，Pub/Sub 最大的优势就是，支持多组生产者、消费者处理消息。
 
1.2.2 发布订阅的缺点
 
讲完了它的优点，那它有什么缺点呢？
 其实，Pub/Sub 最大问题是：丢数据
 
如果发生以下场景，就有可能导致数据丢失：
 
消费者下线
Redis 宕机
消息堆积
 
究竟是怎么回事？
 这其实与 Pub/Sub 的实现方式有很大关系。
 Pub/Sub 在实现时非常简单，它没有基于任何数据类型，也没有做任何的数据存储，它只是单纯地为生产者、消费者建立数据转发通道，把符合规则的数据，从一端转发到另一端。
 
一个完整的发布、订阅消息处理流程是这样的：
 
消费者订阅指定队列，Redis 就会记录一个映射关系：队列->消费者
生产者向这个队列发布消息，那 Redis 就从映射关系中找出对应的消费者，把消息转发给它
 

 看到了么，整个过程中，没有任何的数据存储，一切都是实时转发的。
 这种设计方案，就导致了上面提到的那些问题。
 例如，如果一个消费者异常挂掉了，它再重新上线后，只能接收新的消息，在下线期间生产者发布的消息，因为找不到消费者，都会被丢弃掉。
 如果所有消费者都下线了，那生产者发布的消息，因为找不到任何一个消费者，也会全部丢弃
 所以，当你在使用 Pub/Sub 时，一定要注意：消费者必须先订阅队列，生产者才能发布消息，否则消息会丢失
 这也是前面讲例子时，我们让消费者先订阅队列，之后才让生产者发布消息的原因。
 另外，因为 Pub/Sub 没有基于任何数据类型实现，所以它也不具备数据持久化的能力。
 也就是说，Pub/Sub 的相关操作，不会写入到 RDB 和 AOF 中，当 Redis 宕机重启，Pub/Sub 的数据也会全部丢失。
 
最后，我们来看 Pub/Sub 在处理消息积压时，为什么也会丢数据？
 当消费者的速度，跟不上生产者时，就会导致数据积压的情况发生。
 如果采用 List 当作队列，消息积压时，会导致这个链表很长，最直接的影响就是，Redis 内存会持续增长，直到消费者把所有数据都从链表中取出。
 但 Pub/Sub 的处理方式却不一样，当消息积压时，有可能会导致消费失败和消息丢失！
 
这是怎么回事？
 还是回到 Pub/Sub 的实现细节上来说。
 每个消费者订阅一个队列时，Redis 都会在 Server 上给这个消费者在分配一个缓冲区，这个缓冲区其实就是一块内存。
 当生产者发布消息时，Redis 先把消息写到对应消费者的缓冲区中。
 之后，消费者不断地从缓冲区读取消息，处理消息。
 

 但是，问题就出在这个缓冲区上
 因为这个缓冲区其实是有上限的（可配置），如果消费者拉取消息很慢，就会造成生产者发布到缓冲区的消息开始积压，缓冲区内存持续增长。
 如果超过了缓冲区配置的上限，此时，Redis 就会强制把这个消费者踢下线
 这时消费者就会消费失败，也会丢失数据。
 
如果你有看过 Redis 的配置文件，可以看到这个缓冲区的默认配置：client-output-buffer-limit pubsub 32mb 8mb 60
 它的参数含义如下：
 
32mb：缓冲区一旦超过 32MB，Redis 直接强制把消费者踢下线
8mb + 60：缓冲区超过 8MB，并且持续 60 秒，Redis 也会把消费者踢下线
 
Pub/Sub 的这一点特点，是与 List 作队列差异比较大的
 从这里你应该可以看出，List 其实是属于拉模型，而 Pub/Sub 其实属于推模型。
 List 中的数据可以一直积压在内存中，消费者什么时候来拉都可以。
 但 Pub/Sub 是把消息先推到消费者在 Redis Server 上的缓冲区中，然后等消费者再来取。
 当生产、消费速度不匹配时，就会导致缓冲区的内存开始膨胀，Redis 为了控制缓冲区的上限，所以就有了上面讲到的，强制把消费者踢下线的机制。
 
好了，现在我们总结一下 Pub/Sub 的优缺点：
 
支持发布 / 订阅，支持多组生产者、消费者处理消息
消费者下线，数据会丢失
不支持数据持久化，Redis 宕机，数据也会丢失
消息堆积，缓冲区溢出，消费者会被强制踢下线，数据也会丢失
 
有没有发现，除了第一个是优点之外，剩下的都是缺点。
 所以，很多人看到 Pub/Sub 的特点后，觉得这个功能很鸡肋
 也正是以上原因，Pub/Sub 在实际的应用场景中用得并不多
 目前只有哨兵集群和Redis 实例通信时，采用了 Pub/Sub 的方案，因为哨兵正好符合即时通讯的业务场景。
 我们再来看一下，Pub/Sub 有没有解决，消息处理时异常宕机，无法再次消费的问题呢？
 其实也不行，Pub/Sub 从缓冲区取走数据之后，数据就从 Redis 缓冲区删除了，消费者发生异常，自然也无法再次重新消费。
 
好，现在我们重新梳理一下，我们在使用消息队列时的需求。
 
当我们在使用一个消息队列时，希望它的功能如下：
 
支持阻塞等待拉取消息
支持发布 / 订阅模式
消费失败，可重新消费，消息不丢失
实例宕机，消息不丢失，数据可持久化
消息可堆积
 
Redis 除了 List 和 Pub/Sub 之外，还有符合这些要求的数据类型吗？
 其实，Redis 的作者也看到了以上这些问题，也一直在朝着这些方向努力着。
 Redis 作者在开发 Redis 期间，还另外开发了一个开源项目 disque
 这个项目的定位，就是一个基于内存的分布式消息队列中间件。
 但由于种种原因，这个项目一直不温不火。
 终于，在 Redis 5.0 版本，作者把 disque 功能移植到了 Redis 中，并给它定义了一个新的数据类型：Stream
 下面我们就来看看，它能符合上面提到的这些要求吗？
 
1.3 Redis中的Stream
 
1.3.1 简单使用
 
趋于成熟的队列：Stream
 我们来看 Stream 是如何解决上面这些问题的
 我们依旧从简单到复杂，依次来看 Stream 在做消息队列时，是如何处理的？
 
首先，Stream 通过 XADD 和 XREAD 完成最简单的生产、消费模型：
 
XADD：发布消息
XREAD：读取消息
 
生产者发布 2 条消息：
 
// *表示让Redis自动生成消息ID
127.0.0.1:6379> XADD queue * name zhangsan
"1618469123380-0"
127.0.0.1:6379> XADD queue * name lisi
"1618469127777-0"
 
使用 XADD 命令发布消息，其中的*表示让 Redis 自动生成唯一的消息 ID
 这个消息 ID 的格式是时间戳-自增序号
 
消费者拉取消息：
 
// 从开头读取5条消息，0-0表示从开头读取
127.0.0.1:6379> XREAD COUNT 5 STREAMS queue 0-0
1) 1) "queue"
   2) 1) 1) "1618469123380-0"
         2) 1) "name"
            2) "zhangsan"
      2) 1) "1618469127777-0"
         2) 1) "name"
            2) "lisi"
 
如果想继续拉取消息，需要传入上一条消息的 ID：
 
127.0.0.1:6379> XREAD COUNT 5 STREAMS queue 1618469127777-0
(nil)
 
没有消息，Redis 会返回 NULL
 
 
以上就是 Stream 最简单的生产、消费
 这里不再重点介绍 Stream 命令的各种参数，我在例子中演示时，凡是大写的单词都是固定参数，凡是小写的单词，都是可以自己定义的，例如队列名、消息长度等等，下面的例子规则也是一样，为了方便你理解，这里有必要提醒一下。
 
下面我们来看，针对前面提到的消息队列要求，Stream 都是如何解决的？
 
1.3.2 stream阻塞拉取
 
Stream 是否支持阻塞式拉取消息？
 可以的，在读取消息时，只需要增加 BLOCK 参数即可
 
// BLOCK 0 表示阻塞等待，不设置超时时间
127.0.0.1:6379> XREAD COUNT 5 BLOCK 0 STREAMS queue 1618469127777-0
 
这时，消费者就会阻塞等待，直到生产者发布新的消息才会返回。
 
1.3.3 Stream支持发布 / 订阅模式
 
也没问题，Stream 通过以下命令完成发布订阅：
 
XGROUP：创建消费者组
XREADGROUP：在指定消费组下，开启消费者拉取消息
 
下面我们来看具体如何做？
 首先，生产者依旧发布 2 条消息：
 
127.0.0.1:6379> XADD queue * name zhangsan
"1618470740565-0"
127.0.0.1:6379> XADD queue * name lisi
"1618470743793-0"
 
之后，我们想要开启 2 组消费者处理同一批数据，就需要创建 2 个消费者组：
 
// 创建消费者组1，0-0表示从头拉取消息
127.0.0.1:6379> XGROUP CREATE queue group1 0-0
OK
// 创建消费者组2，0-0表示从头拉取消息
127.0.0.1:6379> XGROUP CREATE queue group2 0-0
OK
 
消费者组创建好之后，我们可以给每个消费者组下面挂一个消费者，让它们分别处理同一批数据。
 
第一个消费组开始消费：
 
// group1的consumer开始消费，>表示拉取最新数据
127.0.0.1:6379> XREADGROUP GROUP group1 consumer COUNT 5 STREAMS queue >
1) 1) "queue"
   2) 1) 1) "1618470740565-0"
         2) 1) "name"
            2) "zhangsan"
      2) 1) "1618470743793-0"
         2) 1) "name"
            2) "lisi"
 
同样地，第二个消费组开始消费：
 
// group2的consumer开始消费，>表示拉取最新数据
127.0.0.1:6379> XREADGROUP GROUP group2 consumer COUNT 5 STREAMS queue >
1) 1) "queue"
   2) 1) 1) "1618470740565-0"
         2) 1) "name"
            2) "zhangsan"
      2) 1) "1618470743793-0"
         2) 1) "name"
            2) "lisi"
 
我们可以看到，这 2 组消费者，都可以获取同一批数据进行处理了。
 
这样一来，就达到了多组消费者「订阅」消费的目的。
 
 
1.3.4 stream不丢消息
 
消息处理时异常，Stream 能否保证消息不丢失，重新消费？
 除了上面拉取消息时用到了消息 ID，这里为了保证重新消费，也要用到这个消息 ID。
 当一组消费者处理完消息后，需要执行 XACK 命令告知 Redis，这时 Redis 就会把这条消息标记为处理完成
 
// group1下的 1618472043089-0 消息已处理完成
127.0.0.1:6379> XACK queue group1 1618472043089-0
 
 
如果消费者异常宕机，肯定不会发送 XACK，那么 Redis 就会依旧保留这条消息。
 待这组消费者重新上线后，Redis 就会把之前没有处理成功的数据，重新发给这个消费者。这样一来，即使消费者异常，也不会丢失数据了。
 
// 消费者重新上线，0-0表示重新拉取未ACK的消息
127.0.0.1:6379> XREADGROUP GROUP group1 consumer1 COUNT 5 STREAMS queue 0-0
// 之前没消费成功的数据，依旧可以重新消费
1) 1) "queue"
   2) 1) 1) "1618472043089-0"
         2) 1) "name"
            2) "zhangsan"
      2) 1) "1618472045158-0"
         2) 1) "name"
            2) "lisi"
 
1.3.5 stream持久化处理
 
Stream 是新增加的数据类型，它与其它数据类型一样，每个写操作，也都会写入到 RDB 和 AOF 中
 我们只需要配置好持久化策略，这样的话，就算 Redis 宕机重启，Stream 中的数据也可以从 RDB 或 AOF 中恢复回来。
 
1.3.6 stream消息堆积
 
消息堆积时，Stream 是怎么处理的？
 其实，当消息队列发生消息堆积时，一般只有 2 个解决方案：
 
生产者限流：避免消费者处理不及时，导致持续积压
丢弃消息：中间件丢弃旧消息，只保留固定长度的新消息
 
而 Redis 在实现 Stream 时，采用了第 2 个方案。
 
在发布消息时，你可以指定队列的最大长度，防止队列积压导致内存爆炸。
 
// 队列长度最大10000
127.0.0.1:6379> XADD queue MAXLEN 10000 * name zhangsan
"1618473015018-0"
 
当队列长度超过上限后，旧消息会被删除，只保留固定长度的新消息。
 这么来看，Stream 在消息积压时，如果指定了最大长度，还是有可能丢失消息的。
 除了以上介绍到的命令，Stream 还支持查看消息长度XLEN、查看消费者状态XINFO等命令，使用也比较简单，你可以查询官方文档了解一下，这里就不过多介绍了。
 
好了，通过以上介绍，我们可以看到，Redis 的 Stream 几乎覆盖到了消息队列的各种场景，是不是觉得很完美？
 既然它的功能这么强大，这是不是意味着，Redis 真的可以作为专业的消息队列中间件来使用呢？
 但是还差一点，就算 Redis 能做到以上这些，也只是趋近于专业的消息队列。
 原因在于 Redis 本身的一些问题，如果把其定位成消息队列，还是有些欠缺的。
 到这里，就不得不把 Redis 与专业的队列中间件做对比了。
 
1.4 与专业消息对比
 
与专业的消息队列对比
 其实，一个专业的消息队列，必须要做到两大块：
 
消息不丢
消息可堆积
 
前面我们讨论的重点，很大篇幅围绕的是第一点展开的。
 这里我们换个角度，从一个消息队列的「使用模型」来分析一下，怎么做，才能保证数据不丢？
 
使用一个消息队列，其实就分为三大块：生产者、队列中间件、消费者
 
 
消息是否会发生丢失，其重点也就在于以下 3 个环节：
 
生产者会不会丢消息？
消费者会不会丢消息？
队列中间件会不会丢消息？
 
1.4.1 生产者会不会丢消息
 
当生产者在发布消息时，可能发生以下异常情况：
 
消息没发出去：网络故障或其它问题导致发布失败，中间件直接返回失败
不确定是否发布成功：网络问题导致发布超时，可能数据已发送成功，但读取响应结果超时了
 
如果是情况 1，消息根本没发出去，那么重新发一次就好了。
 如果是情况 2，生产者没办法知道消息到底有没有发成功？所以，为了避免消息丢失，它也只能继续重试，直到发布成功为止。
 生产者一般会设定一个最大重试次数，超过上限依旧失败，需要记录日志报警处理。
 也就是说，生产者为了避免消息丢失，只能采用失败重试的方式来处理。
 但发现没有？这也意味着消息可能会重复发送。
 是的，在使用消息队列时，要保证消息不丢，宁可重发，也不能丢弃。
 那消费者这边，就需要多做一些逻辑了。
 对于敏感业务，当消费者收到重复数据数据时，要设计幂等逻辑，保证业务的正确性。
 从这个角度来看，生产者会不会丢消息，取决于生产者对于异常情况的处理是否合理。
 所以，无论是 Redis 还是专业的队列中间件，生产者在这一点上都是可以保证消息不丢的。
 
1.4.2 消费者会不会丢消息
 
这种情况就是我们前面提到的，消费者拿到消息后，还没处理完成，就异常宕机了，那消费者还能否重新消费失败的消息？
 要解决这个问题，消费者在处理完消息后，必须「告知」队列中间件，队列中间件才会把标记已处理，否则仍旧把这些数据发给消费者。
 这种方案需要消费者和中间件互相配合，才能保证消费者这一侧的消息不丢。
 无论是 Redis 的 Stream，还是专业的队列中间件，例如 RabbitMQ、Kafka，其实都是这么做的。
 所以，从这个角度来看，Redis 也是合格的。
 
1.4.3 队列中间件会不会丢消息
 
前面 2 个问题都比较好处理，只要客户端和服务端配合好，就能保证生产端、消费端都不丢消息。
 但是，如果队列中间件本身就不可靠呢？
 
毕竟生产者和消费这都依赖它，如果它不可靠，那么生产者和消费者无论怎么做，都无法保证数据不丢。
 在这个方面，Redis 其实没有达到要求。
 Redis 在以下 2 个场景下，都会导致数据丢失。
 AOF 持久化配置为每秒写盘，但这个写盘过程是异步的，Redis 宕机时会存在数据丢失的可能
 主从复制也是异步的，主从切换时，也存在丢失数据的可能（从库还未同步完成主库发来的数据，就被提成主库）
 基于以上原因我们可以看到，Redis 本身的无法保证严格的数据完整性。
 所以，如果把 Redis 当做消息队列，在这方面是有可能导致数据丢失的。
 
再来看那些专业的消息队列中间件是如何解决这个问题的？
 像 RabbitMQ 或 Kafka 这类专业的队列中间件，在使用时，一般是部署一个集群，生产者在发布消息时，队列中间件通常会写多个节点，以此保证消息的完整性。这样一来，即便其中一个节点挂了，也能保证集群的数据不丢失。
 也正因为如此，RabbitMQ、Kafka在设计时也更复杂。毕竟，它们是专门针对队列场景设计的。
 但 Redis 的定位则不同，它的定位更多是当作缓存来用，它们两者在这个方面肯定是存在差异的。
 
1.4.4 消息积压怎么办
 
因为 Redis 的数据都存储在内存中，这就意味着一旦发生消息积压，则会导致 Redis 的内存持续增长，如果超过机器内存上限，就会面临被 OOM 的风险。
 所以，Redis 的 Stream 提供了可以指定队列最大长度的功能，就是为了避免这种情况发生。
 但 Kafka、RabbitMQ 这类消息队列就不一样了，它们的数据都会存储在磁盘上，磁盘的成本要比内存小得多，当消息积压时，无非就是多占用一些磁盘空间，相比于内存，在面对积压时也会更加坦然
 
综上，我们可以看到，把 Redis 当作队列来使用时，始终面临的 2 个问题：
 
Redis 本身可能会丢数据
面对消息积压，Redis 内存资源紧张
 
到这里，Redis 是否可以用作队列，我想这个答案你应该会比较清晰了。
 如果你的业务场景足够简单，对于数据丢失不敏感，而且消息积压概率比较小的情况下，把 Redis 当作队列是完全可以的。
 而且，Redis 相比于 Kafka、RabbitMQ，部署和运维也更加轻量。
 如果你的业务场景对于数据丢失非常敏感，而且写入量非常大，消息积压时会占用很多的机器资源，那么我建议你使用专业的消息队列中间件。
 

 
我来给你解释：
 
第一，通过jedis 储存对象有大概三种，one：本课程的序列化成byte字节 ，最终存byte字节，two：对象转hashmap，也就是你想表达的hash的形式，最终存map，three：对象转json，最终存json，其实也就是字符串
 
第二：其实如果你是平常的项目，并发不高，三个选择都可以，反而你说的hash的形式更加灵活，可以对象的单个属性，但是来了，秒杀的场景的情况下，三者的效率差别很大的
 
第三：结果如下
 
10w数据          时间    内存占用
 
存json               10s        14M
 
存byte               6s            6M
 
存jsonMap      10s          20M
 
存byteMap      4s             4M
 
取json              7s
 
取byte              4s
 
取jsonmap      7s
 
取bytemap      4s
 
第四：你该说了，bytemap最快啊，为啥不用啊，因为作者用了超级强悍的序列化工具啊，以上测试基于java的序列化，如果改了序列化工具，你可以测试下。
 
因本人能力有限，以上可能有谬论，恳请指正

前言
 
做后端开发的童鞋肯定都知道Redis，这是一个性能非常不错的非关系型数据库，通常扮演缓存的角色来存在于项目当中。
 
Redis的应用场景还是不少的，比如：缓存、排行榜、分布式会话、分布式锁、计数器、简单的消息队列等。
 
对于它能当一个简单的消息队列这件事，我还是比较好奇的，所以最近就研究了一下，随手写下这篇文章来做个总结。
 
先说结论：Redis的确可以充当消息队列，但是不推荐。
 
发布/订阅（pub/sub）
 
Publish/Subscribe 是目前广泛使用的通信模型，它采用事件作为基本的通信机制，提供大规模系统所要求的松散耦合的交互模式。订阅者（如客户端）以事件订阅的方式表达出它有兴趣接收的一个事件或一类事件；发布者（如服务器）可将订阅者感兴趣的事件随时通知相关订阅者。
 
简单总结就是：
 
发布订阅 (Pub/Sub) 是一种消息通信模式：发送者 (Pub) 发送消息，订阅者 (Sub) 接收消息。
 
熟悉设计模式的童鞋应该了解这与23种设计模式中的观察者模式极为相似。
 
Redis的发布/订阅
 
在Redis中，每个客户端可以订阅任意数量的频道（Channel）。
 
下图展示了频道channel1，以及订阅这个频道的三个客户端之间的关系：
 
 
当有新消息通过PUBLISH命令发送给频道channel1时，这个消息就会被发送给订阅它的三个客户端：
 
 
演示如下：
 
 
客户端常用命令
 
命令
解释
publish channel message
向指定的channel中发布消息
subscribe channel1 [channel2…]
订阅给定的一个或多个渠道的消息
unsubcribe [channel1 [channel2…]]
取消订阅给定的一个或多个渠道的消息
psubscribe pattern1 [pattern2…]
订阅一个或多个符合给定模式的频道
punsubscribe [pattern1 [pattern2…]]
退订所有给定模式的频道
pubsub channel
列出至少有一个订阅者的频道
pubsub numsub [channel…]
列出给定频道的订阅者数量
Java整合Redis的发布订阅
 
以SpringBoot项目为例，整合Redis实现发布订阅。
 
引入依赖
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
 
配置Redis的连接信息
 
通过查看RedisTemplate的源码，我发现如果你是在本地电脑上启动的Redis，而且端口是默认的，那么下面的配置信息可以不写。
 
spring.redis.database=0
spring.redis.host=localhost
spring.redis.port=6379
 
消费者
 
@Component
public class RedisReceiver {

    public void receiveMessage(String jsonMsg){
        System.out.println("receiveMessage 消费了消息：" + jsonMsg);
    }
}
 
生产者
 
@EnableScheduling
@Component
public class PublishService {

    @Autowired
    private RedisTemplate redisTemplate;

    @Scheduled(fixedRate = 5000)
    public void hello() {
        redisTemplate.convertAndSend("world", JSONObject.toJSONString(System.currentTimeMillis()));
    }
}
 
消息配置类
 
@Configuration
@EnableCaching
public class RedisMessageConfig {

    @Bean
    public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic("world"));
        return container;
    }

    @Bean
    public MessageListenerAdapter listenerAdapter(RedisReceiver receiver) {
        MessageListenerAdapter listenerAdapter = new MessageListenerAdapter(receiver, "receiveMessage");
        listenerAdapter.setSerializer(new JdkSerializationRedisSerializer());
        return listenerAdapter;
    }

    @Bean
    public StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
    }
}
 
效果
 
生产者每5秒会往名叫world的频道中发送当前系统的时间戳，消费者获取到消息并打印到控制台。
 
 
分析
 
消息队列通常适用于多个不同的系统进行信息通信，如果把上面的消费者和生产者分别写在不同的项目中，就会发现，如果你的消费者突然意外挂掉了，由于使用Redis作为消息队列这种方案是无法将数据进行持久化的，所以不可避免的会导致消息的丢失！
 
这种方案的的缺陷就在于客户端必须一直在线才能接收到消息。
 
结论
 
不推荐Redis作为消息队列的原因有以下两点：
 
系统稳定性：在旧版的Redis中，如果一个客户端订阅了某个或者某些频道，但是它读取消息的速度不够快，那么不断的积压的消息就会使得Redis输出缓冲区的体积越来越大，这可能会导致Redis的速度变慢，甚至直接崩溃。也可能会导致Redis被操作系统强制杀死，甚至导致操作系统本身不可用。
数据可靠性：任何网络系统在执行操作时都可能会遇到断网的情况。而断线产生的连接错误通常会使得网络连接两端中的一端进行重新连接。如果客户端在执行订阅操作的过程中断线，那么客户端将会丢失在断线期间的消息，这在很多业务场景下是不可忍受的。
 
参考资料
 
https://www.cnblogs.com/xinde123/p/8489054.html
https://my.oschina.net/u/2457218/blog/3065021