你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列姆巴佩射门造点并亲自主罚命中，巴黎1
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列打成一片！举着酒杯嘻嘻哈哈玩得很开心，拜仁众将啤酒节挑战
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列抛弃李佳琦的年轻人，涌进“三个小老头”的直播间
超级奶爸，梅西把西罗和马特奥逗得哈哈大笑
美团直播助手app下载
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列与多特的那些尘“蜂”往事，巴黎预热与大黄蜂的强强对话
娱乐
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列知识
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列与多特的那些尘“蜂”往事，巴黎预热与大黄蜂的强强对话
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客户端。
践诺如下指示把用户进货竹帛的下单音问寄阁阁到 hotlist:books队列，音问本色症结由 payerID、amount 和 orderID。
> XADD hotlist:books * payerID 1 amount 69.00 orderID 91679218539571-0> XADD hotlist:books * payerID 1 amount 36.00 orderID 151679218572182-0> XADD hotlist:books * payerID 2 amount 99.00 orderID 881679218588426-0> XADD hotlist:books * payerID 3 amount 68.00 orderID 801679218604492-0hotlist:books 是 Stream 的称谓，背面的 “*” 露出让 Redis 为插入的音问自愿生成一个独一 ID，你也能够自界说。
音问 ID 由两部门组成。
肖材积：“若何领路 Stream 是一种只践诺追加独霸（append only）的数据结构？”
通过将元素 ID 与期间进行联系，并逼迫请求新元素的 ID 必须大于旧元素的 ID, Redis 从逻辑上将 Stream 酿成了一种只践诺追加独霸（append only）的数据结构。
用户能够肯定，新的音问和变乱只会呈而今已有音问和变乱之后，就像现实寰宇里新变乱老是爆发在已有变乱之后雷同，齐备都是有序进行的。
❝
肖材积：“插入的音问 ID 大部门雷同，譬喻这四条音问的 ID 都是 1679218 前缀。此外，每条音问键值对的键通常都是雷同的，譬喻这四条音问的键都是 payerID、amount 和 orderID。骗捏散列表存储的话会许多冗尾数据，你这样抠门，是以不骗捏散列表对造故故？”
没缺陷，小老弟很颖慧。为了节约内存，我骗捏了 Radix Tree 和 listpack。Radix Tree 的 key 存储音问 ID，value 骗捏 listpack 数据结构存储多个音问， listapck 华厦音问 ID 都大于等于 key 存储的音问 ID。
我在前面曾经道过 listpack，这是一个紧凑型列表，额外节约内存。而 Radix Tree 数据结构的最大特质是适当覆灭拥有雷同前缀的数据，从而达到节约内存。
终竟 Radix Tree 是若何的数据结构，连缀往下顾念记挂。
Radix Tree，也被称为 Radix Trie，能够 Compact Prefix Tree)，用于高效地存储和查找字符串齐集。它将字符串遵照前缀拆分红一个个字符，并将每个字符行径一个节点存储在树中。
当插入一个键值对时，Redis 会将键遵照字符拆分红一个个字符，并遵照字符在 Radix tree 华厦职位找到适当的节点，要是该节点不糊口，则设立新节点并补充到 Radix tree 中。
当集体字符都补充结束后，将值目的指针覆灭到终末一个节点中。当究诘一个键时，Redis 遵照字符顺次遍历 Radix tree，要是露出某个字符不糊口于树中，则键不糊口；否则，要是终末一个节点露出一个齐备的键，则返回对应的值目的。
如下图露出一个轻省的前缀树，将根节点到叶子节点的阶梯对应字符拼接起来，就赢得了两个 key（“他说碉堡了”、“他说碉炸了”）。
你该当露出了，这两个 key 领有群众前缀（他说碉），前缀树落成了分享骗捏，这样就能够预防雷同字符串重复存储。要是采纳散列表的覆灭花式，阿谁 key 的雷同前缀就会被频频存储，招致内存虚耗。
每个节点只覆灭一个字符，一是会虚耗内存空间，二是在进行究诘时，还须要逐个结婚每个节点露出的字符，对究诘职能也会酿成训诲。
是以，Redis 并莫得直接骗捏范例前缀树，而是做了一次变种——Compact Prefix Tree（缩短前缀树）。通常来说，当多个 key 拥有雷同的前缀时，那就将雷同前缀的字符阿谀结在一个分享节点中，从而减轻存储空间。
如下几个 key（test、toaster、toasting、slow、slowly）在 Radix Tree 上的结构。
鉴于 Compact Prefix Tree 能够分享雷同前缀的节点，是以在存储一组拥有雷同前缀的键时，Redis 的 Radix tree 比此外数据结构（如哈希表）拥有更低的空间耗尽和更快的究诘速率。
Radix Tree 节点的数据结构由 rax.h文献华厦 raxNode 界说。
typedef struct raxNode { uint32_t iskey:1; uint32_t isnull:1; uint32_t iscompr:1; uint32_t size:29; unsigned char data[];} raxNode;Radix Tree 最大的特质就是适当覆灭拥有雷同前缀的数据，落成节约内存的目的，以及赞助限定查找。而这个就是 Stream 采纳 Radix Tree 行径底层数据结构的起因。
责任编辑：姜华 源泉： 码哥字节 Redis音问队列小学语文app
你好，构落我是成道码哥，一个拥抱硬核身手和目的据结，面向黎民币编程的构落须眉，配阁阁星标不迷途。成道
我在【Redis 据结骗捏 List 落成音问队列的利与弊】说过骗捏 List 落成音问队列有许多限度性。
Stream 是 Redis 5.0 版本特意为音问队列设计的数据规范，鉴戒了 Kafka 的 Consume Group 设计脉络，提供了销耗组概记挂。
同期提供了音问的耐久化和主从复制机制，客户端能够造访任何期间的数据，而且能记着每一个客户端的造访职位，从而担保音问不销耗。
以下几个是 Stream 规范的症结特质。
须要瞩目的是，Redis Stream 是一种超轻量级的 MQ，并莫得无缺落成音问队列的集体设计重点，是以它的骗捏处景须要酌量贸易的数据量和对职能、靠得住性的须要。
适当编制音问量不大，忍受数据销耗，骗捏 Redis Stream 行径音问队列就能纳福高职能连辛苦读写音问的优势。
每个 Stream 都有一个独一的称谓，行径 Stream 在 Redis 的 key，在首次骗捏 xadd 指示补充音问的韶华会自愿设立。
能够顾念记挂到 Stream 在一个 Redix Tree 树上，树上存储的是音问 ID，每个音问 ID 对应的音问通过一个指针指向 listpack。
Stream 流就像是一个仅追加本色的音问链表，把音问一个个串起来，每个音问都有一个独一的 ID 和音问本色，音问本色则由多个 field/value 键值对组成。底层骗捏 Radix Tree 和 listpack 数据结构存储数据。
为了便于领路，我画了一张图，并对 Radix Tree 的存储数据做了下变形，骗捏列表来阐述 Stream 中音问的逻辑有序性。
这张图触及许多概记挂，然而你不要慌。我一步步拆户口说，终末你再追想顾念记挂就懂了。
先带你屡下集体脉络。
Streams 结构的源码界说在 stream.h 源码华厦 stream 结构体中。
typedef struct stream { rax *rax; uint64_t length; streamID last_id; streamID first_id; streamID max_deleted_entry_id; uint64_t entries_added; rax *cgroups;} stream;typedef struct streamID { uint64_t ms; uint64_t seq;} streamID;Consumer Group 由 streamCG 结构体界说，每个 Stream 能够有多个 Consumer Group，一个销耗组能够有多个销耗者同期对组内音问进行销耗。
/* Consumer group. */typedef struct streamCG { streamID last_id; long long entries_read; rax *pel; rax *consumers;} streamCG;streamCG -> *pel 对应的 value 是一个 streamNACK 实例，用于笼统销耗者曾经读捏，然而未 ACK 的音问 ID 相故故音问。
/* Pending (yet not acknowledged) message in a consumer group. */typedef struct streamNACK { mstime_t delivery_time; uint64_t delivery_count; streamConsumer *consumer;} streamNACK;Consumer Group 中对 Consumer 的笼统。
/* A specific consumer in a consumer group. */typedef struct streamConsumer { mstime_t seen_time; sds name; rax *pel;} streamConsumer;终末来一张图，便于你领路。
肖材积：“Redis 你好，Stream 若何麇集 Radix Tree 和 listpack 结构来存储音问？为什么不骗捏散列表来存储，音问 ID 行径散列表的 key，散列表的 value 存储音问键值对本色。’”
在答复曾经，先插入几条音问到 Stream，让你对 Stream 音问的存储花色有个大领路知。
该夂箢的语法如下。
XADD key id field value [field value ...]Stream 华厦每个音问能够贮蓄迥异数量的多个键值对，写入音问获胜后，我会把音问的 ID 返回给客