Redis源码分析（三）双向链表-adlist

概述

Redis中的list结构的数据结构是双向链表，双向链表也叫双链表，是链表的一种，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。
优点：从双向链表中的任意一个结点开始，都可以很方便地访问前驱结点和后继结点。
缺点：相比较于单链表的删除、增加节点，操作略微复杂，而且在内存上，需要多分配一个指针存储空间。

内存结构

结构体

可以看到在list结构体当中包含了两个listNode类型的结构体，head代表链表的首节点，tail表示链表的尾节点。list实现了C语言的多态——三个函数指针。*(*dup)是复制当前节点、(*free)是释放当前节点，(*match)是比较两个节点的值是否相等。使用函数指针可以使得开发者在不影响程序的大体逻辑的情况下自定义处理逻辑。listNode是用来存储实际数据的结构体，它是一个双向链表，有一个指向前驱节点的结构体指针prev，一个指向后置节点的结构体指针next，还有一个记录值的任意类型的value。

typedef struct listNode {

    // 前置节点
    struct listNode *prev;

    // 后置节点
    struct listNode *next;

    // 节点的值
    void *value;

} listNode;

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;

内存图

预编译函数

使用了预编译定义了对结构体进行取值的操作，相比之下，预编译的命名更加清晰规范，可以做到见名知其意思。

// 返回给定链表所包含的节点数量
// T = O(1)
#define listLength(l) ((l)->len)

// 返回给定链表的表头节点
// T = O(1)
#define listFirst(l) ((l)->head)

// 返回给定链表的表尾节点
// T = O(1)
#define listLast(l) ((l)->tail)

// 返回给定节点的前置节点
// T = O(1)
#define listPrevNode(n) ((n)->prev)

// 返回给定节点的后置节点
// T = O(1)
#define listNextNode(n) ((n)->next)

// 返回给定节点的值
// T = O(1)
#define listNodeValue(n) ((n)->value)

// 将链表 l 的值复制函数设置为 m
// T = O(1)
#define listSetDupMethod(l,m) ((l)->dup = (m))

// 将链表 l 的值释放函数设置为 m
// T = O(1)
#define listSetFreeMethod(l,m) ((l)->free = (m))

// 将链表的对比函数设置为 m
// T = O(1)
#define listSetMatchMethod(l,m) ((l)->match = (m))

// 返回给定链表的值复制函数
// T = O(1)
#define listGetDupMethod(l) ((l)->dup)

// 返回给定链表的值释放函数
// T = O(1)
#define listGetFree(l) ((l)->free)

// 返回给定链表的值对比函数
// T = O(1)
#define listGetMatchMethod(l) ((l)->match)

遍历的方式

在adlist.h文件中，定义好了两个宏。_HEAD表示从链表的首节点，通过 listNode *head指针循环访问；反之，_TAIL表示从链表的尾部节点，通过 listNode *tail指针循环访问。

// 从表头向表尾进行迭代
#define AL_START_HEAD 0

// 从表尾到表头进行迭代
#define AL_START_TAIL 1

listCreate 创建链表

创建链表逻辑非常简单，使用zmalloc函数分配内存，在分配成功的情况下,初始化结构体中的变量，把前驱、后驱节点同时设置为NULL;

list *listCreate(void)
{
    struct list *list;

    // 分配内存
    if ((list = zmalloc(sizeof(*list))) == NULL)
        return NULL;

    // 初始化属性
    list->head = list->tail = NULL;
    list->len = 0;
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;

    return list;
}

listRelease 释放整个链表

listRelease释放list结构体同时释放节点的所有数据。current是当前节点指针，next是下一个节点的指针。在while循环时，首先把下一个节点的指针指针保存下来，如果有设置函数指针free，就会调用free释放value的空间，再释放节点，最后把next指针传递给current，用作下次循环。把所有节点释放完毕后，调用zfree释放链表。

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);

        // 释放节点结构
        zfree(current);

        current = next;
    }

    // 释放链表结构
    zfree(list);
}

listAddNodeHead 增加头节点并设置值

listAddNodeHead函数会初始化一个listNode结构体，把*value保存到这个结构体当中。在空串的情况下，会把首、尾节点都指向这个node，并且把node的前驱后驱节点都设置为NULL;在非空串的情况下，会把链表的原有头节点向后挪动，把node节点插入到第一个位置。

list *listAddNodeHead(list *list, void *value)
{
    listNode *node;

    // 为节点分配内存
    if ((node = zmalloc(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;
}

listAddNodeTail 增加尾节点并设置值

listAddNodeTail函数的实现原理与listAddNodeHead函数一致。在空串的情况下，会把首、尾节点都指向这个node，并且把node的前驱后驱节点都设置为NULL;在非空串的情况下，会把链表的原有尾节点向前挪动，把node节点插入到最后一个位置。

list *listAddNodeTail(list *list, void *value)
{
    listNode *node;

    // 为新节点分配内存
    if ((node = zmalloc(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;
}

listInsertNode 插入节点

创建一个值为 value 的新节点，在after 为真时，将新节点插入到 old_node 前面，after 为假时 ，将新节点插入到 old_node 后面。

list *listInsertNode(list *list, listNode *old_node, void *value, int after) {
    listNode *node;

    // 创建新节点
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;

    // 保存值
    node->value = value;

    // 将新节点添加到给定节点之后
    if (after) {
        node->prev = old_node;
        node->next = old_node->next;
        // 给定节点是原表尾节点
        if (list->tail == old_node) {
            list->tail = node;
        }
    // 将新节点添加到给定节点之前
    } else {
        node->next = old_node;
        node->prev = old_node->prev;
        // 给定节点是原表头节点
        if (list->head == old_node) {
            list->head = node;
        }
    }

    // 更新新节点的前置指针
    if (node->prev != NULL) {
        node->prev->next = node;
    }
    // 更新新节点的后置指针
    if (node->next != NULL) {
        node->next->prev = node;
    }

    // 更新链表节点数
    list->len++;

    return list;
}

listDelNode 删除节点

从链表 list 中删除给定节点 node，在node节点的前驱节点有值的情况下，把node的后驱节点的地址传递给前驱动节点的后驱节点，如果前驱没有值，表示当前此节点是首节点，则把node的后驱节点的地址传递给list的指向的头节点。在调整完node的前驱节点后，接下来对后驱节点进行调整，而后驱节点正好与前驱节点操作相反。在node节点的后驱节点有值的情况下，把node的前驱节点的地址传递给后驱动节点的后驱节点，如果前驱没有值，表示当前此节点是尾部节点，则把node的后驱节点的地址传递给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);

    // 释放节点
    zfree(node);

    // 链表数减一
    list->len--;
}

listGetIterator 创建一个链表的遍历器

listGetIterator是一个遍历器，它会创建一个listIter类型的结构体， listNode *next作为零时中间变量存储当前遍历的节点，direction表示迭代的方向，direction等于0从首节点开始遍历，direction等于1从尾节点开始遍历。listReleaseIterator函数会释这个迭代器。

/*
 * 双端链表迭代器
 */
typedef struct listIter {

    // 当前迭代到的节点
    listNode *next;

    // 迭代的方向
    int direction;

} listIter;

listIter *listGetIterator(list *list, int direction)
{
    // 为迭代器分配内存
    listIter *iter;
    if ((iter = zmalloc(sizeof(*iter))) == NULL) return NULL;

    // 根据迭代方向，设置迭代器的起始节点
    if (direction == AL_START_HEAD)
        iter->next = list->head;
    else
        iter->next = list->tail;

    // 记录迭代方向
    iter->direction = direction;

    return iter;
}

void listReleaseIterator(listIter *iter) {
    zfree(iter);
}

listRewind listRewindTail 设置迭代器的方向

listRewind 设置链表从头部开始遍历，listRewindTail设置链表从尾部开始遍历。两个函数内个有一个宏定义，它们的值分别是AL_START_HEAD == 0，AL_START_TAIL== 1；

void listRewind(list *list, listIter *li) {
    li->next = list->head;
    li->direction = AL_START_HEAD;
}

void listRewindTail(list *list, listIter *li) {
    li->next = list->tail;
    li->direction = AL_START_TAIL;
}

listNext 设置迭代器下一个遍历的节点

可以看到Redis的设计中，解耦合性非常场，对于函数做到了最细腻度的划分。在下一个节点有值的情况下，判断是头遍历还是尾遍历，让listIter指向前驱或者后驱节点。

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;
}

listDup 复制链表

这个函数是list结构体中的默认的void *(*dup)(void *ptr)函数指针的实现。如果内存不足的情况下，会返回NULL。它会对链表的每个节点和三个指针函数进行拷贝。需要特别注意的是，如果节点有dup函数，就会调用dup函数进行value的拷贝，否者会对原链表共享value指针，如果后续会对list的节点进行值的写操作，会产生一定的冲突。

list *listDup(list *orig)
{
    list *copy;
    listIter *iter;
    listNode *node;

    // 创建新链表
    if ((copy = listCreate()) == NULL)
        return NULL;

    // 设置节点值处理函数
    copy->dup = orig->dup;
    copy->free = orig->free;
    copy->match = orig->match;

    // 迭代整个输入链表
    iter = listGetIterator(orig, AL_START_HEAD);
    while((node = listNext(iter)) != NULL) {
        void *value;

        // 复制节点值到新节点
        if (copy->dup) {
            value = copy->dup(node->value);
            if (value == NULL) {
                listRelease(copy);
                listReleaseIterator(iter);
                return NULL;
            }
        } else
            value = node->value;

        // 将节点添加到链表
        if (listAddNodeTail(copy, value) == NULL) {
            listRelease(copy);
            listReleaseIterator(iter);
            return NULL;
        }
    }

    // 释放迭代器
    listReleaseIterator(iter);

    // 返回副本
    return copy;
}

listSearchKey 判断节点的值

查找链表 list 中值和 key 匹配的节点，判断是否相等的函数由指针函数match来进行，如果没有指针函数，将会比较其地址判断是否相等。

listNode *listSearchKey(list *list, void *key)
{
    listIter *iter;
    listNode *node;

    // 迭代整个链表
    iter = listGetIterator(list, AL_START_HEAD);
    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;
}

listIndex 通过索引获取节点

如果索引为负数，从表尾开始查找，反之，如果索引为正数，从表头开始查找，如果超出了返回会返回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;
}

listRotate 链表转置

取出链表的表尾节点，并将它移动到表头，成为新的表头节点。

void listRotate(list *list) {
    listNode *tail = list->tail;

    if (listLength(list) <= 1) return;

    /* Detach current tail */
    // 取出表尾节点
    list->tail = tail->prev;
    list->tail->next = NULL;

    /* Move it as head */
    // 插入到表头
    list->head->prev = tail;
    tail->prev = NULL;
    tail->next = list->head;
    list->head = tail;
}