Redis 的链表数据结构主要用于实现 Redis 的列表类型（List），在实际应用中有多种场景可以使用。以下是一些常见的应用场景：
1. 消息队列
Redis 列表可以用作简单的消息队列系统。生产者可以将消息推入列表的一端（例如右端），而消费者从另一端（例如左端）弹出消息进行处理。
# 生产者 PUSH 消息到列表尾部
RPUSH message_queue "message1"
RPUSH message_queue "message2"
# 消费者从列表头部 POP 消息
LPOP message_queue
2. 发布/订阅模型
结合 Redis 的 Pub/Sub 功能，链表可以用于实现发布/订阅模型中的消息存储。例如，在某些情况下，可以将消息先存储在链表中，然后再通过订阅机制发送给订阅者。
3. 任务调度
链表可以用于任务调度系统。任务按照一定顺序插入链表，并由调度器按顺序执行。例如，延迟队列可以通过定时扫描链表来实现。
4. 聊天记录存储
在聊天室应用中，链表可以用于存储聊天记录。每次新消息到达时，将其追加到链表尾部。用户可以根据需要读取最新的 N 条消息。
# 添加新消息到链表尾部
RPUSH chat_messages "user1: hello"
RPUSH chat_messages "user2: hi"
# 获取最新的10条消息
LRANGE chat_messages -10 -1
5. 缓存最近访问记录
链表非常适合实现最近访问记录的缓存。可以将最近访问的页面或数据存储在链表中，通过 LRU（Least Recently Used）算法管理缓存。
# 访问某个页面时，首先删除已有的记录（如果存在）
LREM recent_pages 0 "page1"
# 然后将该页面添加到链表头部
LPUSH recent_pages "page1"
# 如果链表长度超过最大限制，移除最老的记录
LTRIM recent_pages 0 99
6. 实现栈和队列
Redis 列表支持 LPUSH/ LPOP 操作，可以用来实现栈（Stack）；支持 RPUSH/ LPOP 操作，可以用来实现队列（Queue）。
# 栈操作：压栈和弹栈
LPUSH stack "item1"
LPUSH stack "item2"
LPOP stack
# 队列操作：入队和出队
RPUSH queue "item1"
RPUSH queue "item2"
LPOP queue
7. 简单的排行榜
可以将用户得分作为分数，将用户 ID 作为列表元素，实现简单的排行榜功能。
# 更新用户得分
LPUSH user_scores "user1:100"
LPUSH user_scores "user2:150"
LPUSH user_scores "user3:120"
# 获取前N名用户
LRANGE user_scores 0 2
底层实现
Redis 中的链表数据结构主要实现了双向链表（Doubly Linked List），用于支持 Redis 的列表类型（List）。链表的具体实现位于 Redis 源码中的 adlist.h 和 adlist.c 文件中。下面是 Redis 链表设计与实现的详细解析。
1. 数据结构定义
双向链表节点（listNode）
每个链表节点包含前驱指针、后继指针以及存储的数据值。
typedef struct listNode {
struct listNode *prev; // 前驱节点指针
struct listNode *next; // 后继节点指针
void *value; // 节点存储的值
} listNode;
双向链表（list）
链表结构包含对头节点、尾节点的引用，以及链表的长度和一系列操作函数指针。
typedef struct list {
listNode *head; // 头节点指针
listNode *tail; // 尾节点指针
void (*dup)(void *ptr); // 节点值复制函数
void (*free)(void *ptr);// 节点值释放函数
int (*match)(void *ptr, void *key); // 节点值匹配函数
unsigned long len; // 链表长度
} list;
链表迭代器（listIter）
用于遍历链表的迭代器，维护当前节点指针和迭代的方向。
typedef struct listIter {
listNode *next; // 当前迭代到的节点
int direction; // 迭代方向
} listIter;
2. 核心函数实现
创建和初始化链表
创建一个新的链表并初始化其成员变量。
list *listCreate(void) {
list *list;
if ((list = malloc(sizeof(*list))) == NULL)
return NULL;
list->head = list->tail = NULL;
list->len = 0;
list->dup = NULL;
list->free = NULL;
list->match = NULL;
return list;
}
释放链表
释放整个链表，包括每个节点。
void listRelease(list *list) {
unsigned long len;
listNode *current, *next;
current = list->head;
len = list->len;
while(len--) {
next = current->next;
if (list->free) list->free(current->value);
free(current);
current = next;
}
free(list);
}
添加节点
在链表头部或尾部添加节点：
list *listAddNodeHead(list *list, void *value) {
listNode *node;
if ((node = malloc(sizeof(*node))) == NULL)
return NULL;
node->value = value;
if (list->len == 0) {
list->head = list->tail = node;
node->prev = node->next = NULL;
} else {
node->prev = NULL;
node->next = list->head;
list->head->prev = node;
list->head = node;
}
list->len++;
return list;
}
list *listAddNodeTail(list *list, void *value) {
listNode *node;
if ((node = malloc(sizeof(*node))) == NULL)
return NULL;
node->value = value;
if (list->len == 0) {
list->head = list->tail = node;
node->prev = node->next = NULL;
} else {
node->prev = list->tail;
node->next = NULL;
list->tail->next = node;
list->tail = node;
}
list->len++;
return list;
}
删除节点
从链表中删除指定节点：
void listDelNode(list *list, listNode *node) {
if (node->prev)
node->prev->next = node->next;
else
list->head = node->next;
if (node->next)
node->next->prev = node->prev;
else
list->tail = node->prev;
if (list->free) list->free(node->value);
free(node);
list->len--;
}
迭代器相关功能
创建迭代器
#define AL_START_HEAD 0
#define AL_START_TAIL 1
listIter *listGetIterator(list *list, int direction) {
listIter *iter;
if ((iter = malloc(sizeof(*iter))) == NULL) return NULL;
if (direction == AL_START_HEAD)
iter->next = list->head;
else
iter->next = list->tail;
iter->direction = direction;
return iter;
}
获取下一个节点
通过迭代器获取链表中的下一个节点：
listNode *listNext(listIter *iter) {
listNode *current = iter->next;
if (current != NULL) {
if (iter->direction == AL_START_HEAD)
iter->next = current->next;
else
iter->next = current->prev;
}
return current;
}
释放迭代器
释放迭代器所占用的内存：
void listReleaseIterator(listIter *iter) {
free(iter);
}
其他常用操作
从链表中查找节点
根据匹配函数，从链表中查找特定值的节点：
listNode *listSearchKey(list *list, void *key) {
listIter *iter = listGetIterator(list, AL_START_HEAD);
listNode *node;
while((node = listNext(iter)) != NULL) {
if (list->match) {
if (list->match(node->value, key)) {
listReleaseIterator(iter);
return node;
}
} else {
if (key == node->value) {
listReleaseIterator(iter);
return node;
}
}
}
listReleaseIterator(iter);
return NULL;
}
获取链表中的特定索引位置的节点
根据索引获取链表中的节点，支持负索引（负索引表示从尾部开始计数）：
listNode *listIndex(list *list, long index) {
listNode *n;
if (index < 0) {
index = (-index)-1;
n = list->tail;
while(index-- && n) n = n->prev;
} else {
n = list->head;
while(index-- && n) n = n->next;
}
return n;
}
总结
Redis 中的双向链表实现提供了一种高效的、灵活的数据结构，支持快速的插入和删除操作。其核心组件包括：
listNode：表示链表中的节点，包含前驱指针、后继指针和节点值。list：表示整个链表，包含头节点、尾节点和链表长度等信息。listIter：用于遍历链表的迭代器，维护当前节点指针和迭代方向。
