redis之adlist

号外号外，新建Redis交流讨论群：332160890，欢迎加入！！

类型介绍

这部分是redis自定义的链表类型，该链表为双向链表，可以自定义存储类型，另外可以自定义释放、拷贝、对比函数等功能，提供的操作也比较丰富，包括创建、添加、插入、删除、索引等步骤，还拥有迭代器功能。

代码分析

自定义类型

链表节点，双向链表

typedef struct listNode {    struct listNode *prev;    struct listNode *next;    void *value;} listNode;

链表迭代器

typedef struct listIter {    listNode *next;   //指向下一个节点    int direction;    //遍历方向} listIter;

链表

typedef struct list {    listNode *head;    //链表头部    listNode *tail;    //链表尾部    void *(*dup)(void *ptr);  //复制内存空间    void (*free)(void *ptr);  //自定义释放空间函数，用于释放value占用空间    int (*match)(void *ptr, void *key);  //自定义比较函数    unsigned long len;  //链表长度} list;

定义变量

代码分解

listCreate，创建一个链表，内部不存储元素，创建失败返回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，释放链表，由于每个元素都是实际分配的内存，必须使用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);  //释放当前value占用的内存        zfree(current);   //释放该节点结构体占用的内存空间        current = next;    }    zfree(list);}

listAddNodeHead，在链表头部添加一个value，分配一个节点放置在链表头；

list *listAddNodeHead(list *list, void *value){    listNode *node;    if ((node = zmalloc(sizeof(*node))) == NULL)        return NULL;  //申请内存    node->value = value;    //这里是不是该判断下list是否为NULL ？    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的头节点设置为该节点    }    list->len++;    return list;  //返回之前传入的链表指针}

listAddNodeTail，为当前value分配一个节点并放置到链表尾部；

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，分配该节点插入到old_node前后，after来表示前后方向；

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;  //如果old_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，删除某个节点；

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);  //如果有自定义内存释放函数，调用去释放节点的value信息    zfree(node);  //释放该节点    list->len--;}

listGetIterator，根据设定的方向（正向还是反向）获取迭代器，这类迭代器比较简单，不涉及锁操作；

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

listReleaseIterator，释放迭代器内存；

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

listRewind，为一个迭代器，设置正向；

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

listRewindTail，为一个迭代器，设置反向；

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

listNext，根据迭代器获取下一个节点；

listNode *listNext(listIter *iter){    listNode *current = iter->next;    if (current != NULL) {        if (iter->direction == AL_START_HEAD)            iter->next = current->next;  //正向，为当前节点的next        else            iter->next = current->prev;  //反向，为当前节点的prev    }    return current;}

listDup，拷贝一个链表；

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;  //将属性函数，直接复制    listRewind(orig, &iter);  //获取迭代器    while((node = listNext(&iter)) != NULL) {  //迭代        void *value;        if (copy->dup) {  //如果指定复制方法            value = copy->dup(node->value);            if (value == NULL) {  //拷贝出错，直接退出                listRelease(copy);                return NULL;            }        } else            value = node->value;  //未指定指向同一地址，两个都可以修改        if (listAddNodeTail(copy, value) == NULL) {            listRelease(copy);  //添加到链表尾部            return NULL;        }    }    return copy;}

listSearchKey，按key查找；

listNode *listSearchKey(list *list, void *key){    listIter iter;    listNode *node;    listRewind(list, &iter);  //分配迭代器    while((node = listNext(&iter)) != NULL) {        if (list->match) {  //如果有匹配函数            if (list->match(node->value, key)) {                return node;            }        } else {  //没有直接对比地址            if (key == node->value) {                return node;            }        }    }    return NULL;  //未找到，返回}

listIndex，获取当前索引对应的节点，从0开始计数；

listNode *listIndex(list *list, long index) {    listNode *n;    if (index < 0) {  //index为负，表示从尾部开始        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;}