redis源码分析与思考（十四）——列表类型的命令实现(t_list.c)

最新推荐文章于 2022-05-30 15:26:52 发布
最新推荐文章于 2022-05-30 15:26:52 发布
阅读量271 收藏
点赞数 1
分类专栏： Redis Redis源码分析与思考 文章标签： redis nosql 源码分析
个人博客：suyeq.com 欢迎访问
本文链接：https://blog.csdn.net/hackersuye/article/details/83116573
版权

    列表类型是用来存贮多个字符串对象的结构。一个列表可以存贮232-1个元素，可以对列表两端进行插入(push)、弹出(pop)，还可以获取指定范围内的元素列表、获取指定索引的元素等等，它可以灵活的充当栈和队列的角色。下面列出列表的命令：

列表命令

操作说明命令时间复杂度
向尾部添加rpush key value [value…]O(n)
向头部添加lpush key value [value…]O(n)
插入在指定键前/后linsert key before/after pivot valueO(n)
返回范围内的键lrange key start endO(n)
返回索引的键lindex key indexO(n)
返回列表的长度llen key indexO(1)
弹出头部节点lpop keyO(1)
弹出尾部节点rpop keyO(1)
删除指定cout数目且值等于value的键lremkey count valueO(n)
删除指定范围的键ltrim key start endO(n)
修改指定索引的键值lset key index valueO(n)
阻塞操作blpop、brpopO(1)

编码的转换

    上次在介绍redis对象时提到过，列表对象的编码格式会在一定情况下从ziplist转变成adlist链表。列表每次push元素时，都会检测是否满足这一情况：

/*
 * 对输入值 value 进行检查，看是否需要将 subject 从 ziplist 转换为双端链表，
 * 以便保存值 value 。
 * 函数只对 REDIS_ENCODING_RAW 编码的 value 进行检查，
 * 因为整数编码的值不可能超长。
 */
 //server.list_max_ziplist_value是服务器的属性，可更改,默认64字节
void listTypeTryConversion(robj *subject, robj *value) {
    // 确保 subject 为 ZIPLIST 编码
    if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;
    if (sdsEncodedObject(value) &&
        // 看字符串是否过长
        sdslen(value->ptr) > server.list_max_ziplist_value)
            // 将编码转换为双端链表
            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
}

/*
 * 将列表的底层编码从 ziplist 转换成双端链表
 */
void listTypeConvert(robj *subject, int enc) {
//定义一个链表的迭代器
    listTypeIterator *li;
    listTypeEntry entry;
    redisAssertWithInfo(NULL,subject,subject->type == REDIS_LIST);
    // 转换成双端链表
    if (enc == REDIS_ENCODING_LINKEDLIST) {
        list *l = listCreate();
        //设置链表的释放函数
        listSetFreeMethod(l,decrRefCountVoid);
        /* listTypeGet returns a robj with incremented refcount */
        // 遍历 ziplist ，并将里面的值全部添加到双端链表中
        li = listTypeInitIterator(subject,0,REDIS_TAIL);
        while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry));
        listTypeReleaseIterator(li);
        // 更新编码
        subject->encoding = REDIS_ENCODING_LINKEDLIST;
        // 释放原来的 ziplist
        zfree(subject->ptr);
        // 更新对象值指针
        subject->ptr = l;
    } else {
        redisPanic("Unsupported list conversion");
    }
}

    也就是说，当列表里插入的元素字节长大于64字节时，列表会启动编码转换程序。

列表的新增

    不仅是插入的元素字节长大于默认的64字节会激动编码转换，新增元素的底层实现，在插入之前会检测列表的总长度是否大于默认ziplist最大长度也会引起编码转换，默认长度是512个元素，可以在服务器的配置中更改，列表插入底层实现如下：

//server.list_max_ziplist_entries表示最大长度，where表示插入到表头还是表尾
void listTypePush(robj *subject, robj *value, int where) {
    /* Check if we need to convert the ziplist */
    // 是否需要转换编码？
    listTypeTryConversion(subject,value);
    if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
        ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)
            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
    // ZIPLIST
    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
        int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
        // 取出对象的值，因为 ZIPLIST 只能保存字符串或整数
        value = getDecodedObject(value);
        subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);
        decrRefCount(value);
    // 双端链表
    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
        if (where == REDIS_HEAD) {
            listAddNodeHead(subject->ptr,value);
        } else {
            listAddNodeTail(subject->ptr,value);
        }
        incrRefCount(value);
    // 未知编码
    } else {
        redisPanic("Unknown list encoding");
    }
}


/*
 * 将对象 value 插入到列表节点的之前或之后。
 * where 参数决定了插入的位置：
 *  - REDIS_HEAD 插入到节点之前
 *  - REDIS_TAIL 插入到节点之后
 */
void listTypeInsert(listTypeEntry *entry, robj *value, int where) {
    robj *subject = entry->li->subject;
    // 插入到 ZIPLIST
    if (entry->li->encoding == REDIS_ENCODING_ZIPLIST) {
        // 返回对象未编码的值
        value = getDecodedObject(value);
        if (where == REDIS_TAIL) {
            unsigned char *next = ziplistNext(subject->ptr,entry->zi);
            /* When we insert after the current element, but the current element
             * is the tail of the list, we need to do a push. */
            if (next == NULL) {
                // next 是表尾节点，push 新节点到表尾
                subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),REDIS_TAIL);
            } else {
                // 插入到到节点之后
                subject->ptr = ziplistInsert(subject->ptr,next,value->ptr,sdslen(value->ptr));
            }
        } else {
            subject->ptr = ziplistInsert(subject->ptr,entry->zi,value->ptr,sdslen(value->ptr));
        }
        decrRefCount(value);
    // 插入到双端链表
    } else if (entry->li->encoding == REDIS_ENCODING_LINKEDLIST) {
        if (where == REDIS_TAIL) {
            listInsertNode(subject->ptr,entry->ln,value,AL_START_TAIL);
        } else {
            listInsertNode(subject->ptr,entry->ln,value,AL_START_HEAD);
        }
        incrRefCount(value);
    } else {
        redisPanic("Unknown list encoding");
    }
}

    PUSH系列命令的底层实现：

void pushGenericCommand(redisClient *c, int where) {
    int j, waiting = 0, pushed = 0;
    // 取出列表对象
    robj *lobj = lookupKeyWrite(c->db,c->argv[1]);
    // 如果列表对象不存在，那么可能有客户端在等待这个键的出现
    int may_have_waiting_clients = (lobj == NULL);
    if (lobj && lobj->type != REDIS_LIST) {
        addReply(c,shared.wrongtypeerr);
        return;
    }
    // 将列表状态设置为就绪
    if (may_have_waiting_clients) signalListAsReady(c,c->argv[1]);
    // 遍历所有输入值，并将它们添加到列表中
    for (j = 2; j < c->argc; j++) {
        // 编码值
        c->argv[j] = tryObjectEncoding(c->argv[j]);
        // 如果列表对象不存在，那么创建一个，并关联到数据库
        if (!lobj) {
            lobj = createZiplistObject();
            dbAdd(c->db,c->argv[1],lobj);
        }
        // 将值推入到列表
        listTypePush(lobj,c->argv[j],where);
        pushed++;
    }
    // 返回添加的节点数量
    addReplyLongLong(c, waiting + (lobj ? listTypeLength(lobj) : 0));
    // 如果至少有一个元素被成功推入，那么执行以下代码
    if (pushed) {
        char *event = (where == REDIS_HEAD) ? "lpush" : "rpush";
        // 发送键修改信号
        signalModifiedKey(c->db,c->argv[1]);
        // 发送事件通知
        notifyKeyspaceEvent(REDIS_NOTIFY_LIST,event,c->argv[1],c->db->id);
    }
    server.dirty += pushed;
}

索引

    索引的策略很简单，判断是哪种编码格式调用哪种遍历：

void lindexCommand(redisClient *c) {
    robj *o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk);
    if (o == NULL || checkType(c,o,REDIS_LIST)) return;
    long index;
    robj *value = NULL;
    // 取出整数值对象 index
    if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != REDIS_OK))
        return;
    // 根据索引，遍历 ziplist ，直到指定位置
    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
        unsigned char *p;
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong；
        p = ziplistIndex(o->ptr,index);
        if (ziplistGet(p,&vstr,&vlen,&vlong)) {
            if (vstr) {
                value = createStringObject((char*)vstr,vlen);
            } else {
                value = createStringObjectFromLongLong(vlong);
            }
            addReplyBulk(c,value);
            decrRefCount(value);
        } else {
            addReply(c,shared.nullbulk);
        }
    // 根据索引，遍历双端链表，直到指定位置
    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
        listNode *ln = listIndex(o->ptr,index);
        if (ln != NULL) {
            value = listNodeValue(ln);
            addReplyBulk(c,value);
        } else {
            addReply(c,shared.nullbulk);
        }
    } else {
        redisPanic("Unknown list encoding");
    }
}

pop操作

    pop操作其实就是将队列的pop操作而已，弹出元素后如果列表为空，则删除该列表：

void popGenericCommand(redisClient *c, int where) {
    // 取出列表对象
    robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk);
    if (o == NULL || checkType(c,o,REDIS_LIST)) return;
    // 弹出列表元素
    robj *value = listTypePop(o,where);
    // 根据弹出元素是否为空，决定后续动作
    if (value == NULL) {
        addReply(c,shared.nullbulk);
    } else {
        char *event = (where == REDIS_HEAD) ? "lpop" : "rpop";
//回复给客户端，弹出的value
        addReplyBulk(c,value);
        //引用计数减1
        decrRefCount(value);
        notifyKeyspaceEvent(REDIS_NOTIFY_LIST,event,c->argv[1],c->db->id);
        if (listTypeLength(o) == 0) {
            notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",
                                c->argv[1],c->db->id);
            dbDelete(c->db,c->argv[1]);
        }
        signalModifiedKey(c->db,c->argv[1]);
        server.dirty++;
    }
}

裁剪操作

//LTRIM命令
void ltrimCommand(redisClient *c) {
    robj *o;
    long start, end, llen, j, ltrim, rtrim;
    list *list;
    listNode *ln;
    // 取出索引值 start 和 end
    if ((getLongFromObjectOrReply(c, c->argv[2], &start, NULL) != REDIS_OK) ||
        (getLongFromObjectOrReply(c, c->argv[3], &end, NULL) != REDIS_OK)) return;
    // 取出列表对象
    if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.ok)) == NULL ||
        checkType(c,o,REDIS_LIST)) return;
    // 列表长度
    llen = listTypeLength(o);
    /* convert negative indexes */
    // 将负数索引转换成正数索引
    if (start < 0) start = llen+start;
    if (end < 0) end = llen+end;
    if (start < 0) start = 0;
    /* Invariant: start >= 0, so this test will be true when end < 0.
     * The range is empty when start > end or start >= length. */
    if (start > end || start >= llen) {
        /* Out of range start or start > end result in empty list */
        ltrim = llen;
        rtrim = 0;
    } else {
        if (end >= llen) end = llen-1;
        ltrim = start;
        rtrim = llen-end-1;
    }
    /* Remove list elements to perform the trim */
    // 删除指定列表两端的元素
    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
        // 删除左端元素
        o->ptr = ziplistDeleteRange(o->ptr,0,ltrim);
        // 删除右端元素
        o->ptr = ziplistDeleteRange(o->ptr,-rtrim,rtrim);
    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
        list = o->ptr;
        // 删除左端元素
        for (j = 0; j < ltrim; j++) {
            ln = listFirst(list);
            listDelNode(list,ln);
        }
        // 删除右端元素
        for (j = 0; j < rtrim; j++) {
            ln = listLast(list);
            listDelNode(list,ln);
        }
    } else {
        redisPanic("Unknown list encoding");
    }
    // 发送通知
    notifyKeyspaceEvent(REDIS_NOTIFY_LIST,"ltrim",c->argv[1],c->db->id);
    // 如果列表已经为空，那么删除它
    if (listTypeLength(o) == 0) {
        dbDelete(c->db,c->argv[1]);
        notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",c->argv[1],c->db->id);
    }
    signalModifiedKey(c->db,c->argv[1]);
    server.dirty++;
    addReply(c,shared.ok);
}

移除列表中指定的值

void lremCommand(redisClient *c) {
    robj *subject, *obj;
    // 编码目标对象 elem
    obj = c->argv[3] = tryObjectEncoding(c->argv[3]);
    long toremove;
    long removed = 0;
    listTypeEntry entry;
    // 取出指定删除模式的 count 参数
    if ((getLongFromObjectOrReply(c, c->argv[2], &toremove, NULL) != REDIS_OK))
        return;
    // 取出列表对象
    subject = lookupKeyWriteOrReply(c,c->argv[1],shared.czero);
    if (subject == NULL || checkType(c,subject,REDIS_LIST)) return;
    /* Make sure obj is raw when we're dealing with a ziplist */
    if (subject->encoding == REDIS_ENCODING_ZIPLIST)
        obj = getDecodedObject(obj);
    listTypeIterator *li;
    // 根据 toremove 参数，决定是从表头还是表尾开始进行删除
    if (toremove < 0) {
        toremove = -toremove;
        li = listTypeInitIterator(subject,-1,REDIS_HEAD);
    } else {
        li = listTypeInitIterator(subject,0,REDIS_TAIL);
    }
    // 查找，比对对象，并进行删除
    while (listTypeNext(li,&entry)) {
        if (listTypeEqual(&entry,obj)) {
            listTypeDelete(&entry);
            server.dirty++;
            removed++;
            // 已经满足删除数量，停止
            if (toremove && removed == toremove) break;
        }
    }
    listTypeReleaseIterator(li);
    /* Clean up raw encoded object */
    if (subject->encoding == REDIS_ENCODING_ZIPLIST)
        decrRefCount(obj);
    // 删除空列表
    if (listTypeLength(subject) == 0) dbDelete(c->db,c->argv[1]);
    addReplyLongLong(c,removed);
    if (removed) signalModifiedKey(c->db,c->argv[1]);
}

阻塞版pop

    阻塞版本的pop其实与普通pop操作没两样，只是加了阻塞操作而已，假如列表为空，阻塞时间为3s，那么客户端要等到3s后返回，如果在期间push了元素，那么立即返回该元素。其底层实现如下：

void blockingPopGenericCommand(redisClient *c, int where) {
    robj *o;
    mstime_t timeout;
    int j;
    // 取出 timeout 参数
    if (getTimeoutFromObjectOrReply(c,c->argv[c->argc-1],&timeout,UNIT_SECONDS)
        != REDIS_OK) return;
    // 遍历所有列表键
    for (j = 1; j < c->argc-1; j++) {
        // 取出列表键
        o = lookupKeyWrite(c->db,c->argv[j]);
        // 有非空列表？
        if (o != NULL) {
            if (o->type != REDIS_LIST) {
                addReply(c,shared.wrongtypeerr);
                return;
            } else {
                // 非空列表
                if (listTypeLength(o) != 0) {
                    /* Non empty list, this is like a non normal [LR]POP. */
                    char *event = (where == REDIS_HEAD) ? "lpop" : "rpop";

                    // 弹出值
                    robj *value = listTypePop(o,where);
                    redisAssert(value != NULL);
                    // 回复客户端
                    addReplyMultiBulkLen(c,2);
                    // 回复弹出元素的列表
                    addReplyBulk(c,c->argv[j]);
                    // 回复弹出值
                    addReplyBulk(c,value);
                    decrRefCount(value);
                    notifyKeyspaceEvent(REDIS_NOTIFY_LIST,event,
                                        c->argv[j],c->db->id);
                    // 删除空列表
                    if (listTypeLength(o) == 0) {
                        dbDelete(c->db,c->argv[j]);
                        notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",
                                            c->argv[j],c->db->id);
                    }
                    signalModifiedKey(c->db,c->argv[j]);
                    server.dirty++;
                    /* Replicate it as an [LR]POP instead of B[LR]POP. */
                    // 传播一个 [LR]POP 而不是 B[LR]POP
                    rewriteClientCommandVector(c,2,
                        (where == REDIS_HEAD) ? shared.lpop : shared.rpop,
                        c->argv[j]);
                    return;
                }
            }
        }
    }
    /* If we are inside a MULTI/EXEC and the list is empty the only thing
     * we can do is treating it as a timeout (even with timeout 0). */
    // 如果命令在一个事务中执行，那么为了不产生死等待
    // 服务器只能向客户端发送一个空回复
    if (c->flags & REDIS_MULTI) {
        addReply(c,shared.nullmultibulk);
        return;
    }
    /* If the list is empty or the key does not exists we must block */
    // 所有输入列表键都不存在，只能阻塞了，阻塞其指定的时间
    blockForKeys(c, c->argv + 1, c->argc - 2, timeout, NULL);
}

// 根据给定数量的 key ，对给定客户端进行阻塞
// 参数：
// keys    任意多个 key
// numkeys keys 的键数量
// timeout 阻塞的最长时限
// target  在解除阻塞时，将结果保存到这个 key 对象，而不是返回给客户端
//         只用于 BRPOPLPUSH 命令
void blockForKeys(redisClient *c, robj **keys, int numkeys, mstime_t timeout, robj *target) {
    dictEntry *de;
    list *l;
    int j;
    // 设置阻塞状态的超时和目标选项
    c->bpop.timeout = timeout;
    // target 在执行 RPOPLPUSH 命令时使用
    c->bpop.target = target;
    if (target != NULL) incrRefCount(target);
    // 关联阻塞客户端和键的相关信息
    for (j = 0; j < numkeys; j++) {
        /* If the key already exists in the dict ignore it. */
        // c->bpop.keys 是一个集合（值为 NULL 的字典）
        // 它记录所有造成客户端阻塞的键
        // 以下语句在键不存在于集合的时候，将它添加到集合
        if (dictAdd(c->bpop.keys,keys[j],NULL) != DICT_OK) continue;
        incrRefCount(keys[j]);
        /* And in the other "side", to map keys -> clients */
        // c->db->blocking_keys 字典的键为造成客户端阻塞的键
        // 而值则是一个链表，链表中包含了所有被阻塞的客户端
        // 以下程序将阻塞键和被阻塞客户端关联起来
        de = dictFind(c->db->blocking_keys,keys[j]);
        if (de == NULL) {
            // 链表不存在，新创建一个，并将它关联到字典中
            int retval;
            /* For every key we take a list of clients blocked for it */
            l = listCreate();
            retval = dictAdd(c->db->blocking_keys,keys[j],l);
            incrRefCount(keys[j]);
            redisAssertWithInfo(c,keys[j],retval == DICT_OK);
        } else {
            l = dictGetVal(de);
        }
        // 将客户端填接到被阻塞客户端的链表中
        listAddNodeTail(l,c);
    }
    blockClient(c,REDIS_BLOCKED_LIST);
}
suye233
关注
专栏目录
Redis源码分析——用剖析工具的方式来分析Redis的底层实现细节”
程序员光剑
07-31 1799
Redis是当今最流行的开源键值数据库之一，其性能卓越、可靠性高、数据类型丰富等特性，已经成为互联网中不同场景下的常见技术选型。作为一个经典的“瑞士军刀”，Redis在互联网领域得到了广泛应用，具有广泛的应用场景。但是随着技术的发展，代码的复杂度也逐渐上升，从而影响了Redis的维护和扩展难度。为了更好地了解和掌握Redis内部工作机制，帮助用户更好地理解其设计思想，提升应用效率，本文将详细介绍Redis的核心模块和工作流程，并通过剖析工具的方式来分析Redis的底层实现细节。
redis源码分析（6）——aof rewrite
架构师专栏
03-23 8138
介绍redis的aof rewirte代码实现
redis学习笔记（13）---列表命令及实现
qinm的专栏
05-10 2261
列表命令Redis中的List对象的类型为REDIS_LIST，是一种双向链表结构，主要支持以下几种命令： LPUSH 向列表左端添加元素，用法：LPUSH key valueRPUSH 向列表右端添加元素，用法：RPUSH key valueLPOP 从列表左端弹出元素，用法：LPOP keyRPOP 从列表右端弹出元素，用法：RPOP keyLLEN 获取列表中元素个数，用法：LLEN keyL
结合redis设计与实现的redis源码学习-8.3-t_list.c（列表键）
YangGangAVA的博客
11-04 403
T_list.c主要说明了列表键和列表键的命令实现方式；#include "server.h" //将一个值放入列表中，根据where判断是头插还是尾插 void listTypePush(robj *subject, robj *value, int where) { if (subject->encoding == OBJ_ENCODING_QUICKLIST) { in
Redis源码剖析--列表t_list实现
harleylau的博客
05-29 1990
Redis中的列表对象比较特殊，在版本3.2之前，列表底层的编码是 ziplist 和 linkedlist 实现的， 但是在版本3.2之后，重新引入了一个 quicklist 的数据结构，列表的底层都由quicklist实现。 这边是在看源码和实际验证的时候发现的区别，然后上网查证。由于目前使用的redis基本都在3.2了， 而且老版本肯定会被取代， 所以我们只分析3.2版本之后的实现。对于老...
Redis源码学习（9），t_list.c 学习（四），学习总结
无痕之意的博客
04-25 1611
  时间过的真快呀，一眨眼又过去了好几天，这几天我们学习了t_list.c文件不少方法，趁今天来总结一番。 1 方法列表   先看一下这个文件都有哪些方法 /*----------------------------------------------------------------------------- * List API *----------------------------------------------------------------------------*/ void
redis之adlist.c
后台开发
11-06 1万+
adlist是redis实现的双端链表，这个双端链表和数据结构中的双链表类似。双端链表list有一个指向链表和一个指向链表尾的指针，list还包括一些函数指针。 如：void *(*dup)(void *ptr); dup是一个函数指针，它指向的这个函数返回值是void *，参数是void *ptr adlist.h /* adlist.h - A gen...
redis源码阅读笔记(6)——ziplist
08-06
Redis是一款高性能的键值对数据库，其内部使用了许多优化的数据结构来存储数据，其中ziplist是Redis为了节省内存而设计...在阅读Redis源码时，深入分析ziplist的实现细节将有助于我们更好地理解和调试Redis的内存管理。
redis-5.0.14.源码
12-11
1. **数据结构**：Redis 的核心在于其高效的数据结构实现，如字符串（String）、哈希表（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。这些数据结构的实现通常采用内存优化的方式，如 SDS（Simple ...
霸榜巨作、阿里内部顶级专家整理（Redis 5设计与源码分析）
uuqaz的博客
05-30 502
前言 在开源界，高性能服务的典型代表就是Nginx和Redis。纵观这两个软件的源码，都是非常简洁高效的，也都是基于异步网络I/O机制的，所以对于要学习高性能服务的程序员或者爱好者来说，研究这两个网络服务的源码是非常有必要的。 Nginx目前市面上的书籍很多，但是Redis确实寥寥无几。这几年Redis版本发展非常快，从稳定的2.x版本，发展到增加了很多优秀特性的5.0版本，这些特性目前尚无资料进行系统讲解。然而小编接下来给大家带来的这本《Redis 5设计与源码分析》书填补了Redis 5.0技术学习
Redis源码学习（6），t_list.c 学习（一），rpush、lpush命令实现学习
无痕之意的博客
04-21 1725
前言   大体学习完t_string.c的代码，我们正式进入下一个文件的学习，这一次我们学习的是t_list.c文件，从文件名我们可以知道这是一个关于列表的相关命令的源代码。   在学习列表命令之前，这里要介绍一下，在Redis中列表的底层数据结构由压缩表和链表实现，所以在今天的学习中会发现大量的底层数据结构判断，根据不同的数据结构使用不同的方法。不过这里要注意的是，这里是基于3.0版本的源代码，3.2版本之后发生了变化，3.2版本之后使用了快速表来实现。 1 pushGenericCommand 1.1
redis c语言 list例子,redis基本数据类型操作之 list
weixin_42371226的博客
05-22 233
list基本操作Redis的list类型其实就是一个每个子元素都是string类型的双向链表。链表的最大长度是(2的32次方)。我们可以通过push,pop操作从链表的头部或者尾部添加删除元素。这使得list既可以用作栈，也可以用作队列。有意思的是list的pop操作还有阻塞版本的，当我们[lr]pop一个list对象时，如果list是空，或者不存在，会立即返回nil。但是阻塞版本的b[lr]po...
TypeError: unsupported operand type(s) for -: 'list' and 'list' 问题解决
热门推荐
小檬
03-22 4万+
近日 python 入门写了个函数，先建立两个数组 y 和 t ，在另一个头文件中定义了一个计算函数，带有 y-t 等运算。数组我是这样建立的： t=[0,0,1,0] y1=[0.1,0.05,0.6,0,0.05] 结果显示错误： TypeError: unsupported operand type(s) for -: ‘list’ and ‘list’ 这是说 y 和 t 不能做 y...
【Redis源码剖析】 - Redis数据类型之列表List
上善若水，人淡如菊
04-16 7953
原创作品，转载请标明：http://blog.csdn.net/Xiejingfa/article/details/51166709 Redis源码剖析系列文章汇总：传送门 今天为大家带来Redis五大数据类型之一 – List的源码分析。 Redis中的List类型是一种双向链表结构，主要支持以下几种命令： lpush、rpush、lpushx、rpushx lpop、rpop、...
【Redis源码剖析】 - Redis数据类型之redisObject
上善若水，人淡如菊
04-13 8385
原创作品，转载请标明：http://blog.csdn.net/Xiejingfa/article/details/51140041 Redis源码剖析系列文章汇总：传送门 在前面六篇文章中，我们逐一分析了字符串sds、双向链表list、字典dict、压缩列表ziplist、压缩字典zipmap、整数集合inset这几种Redis内置数据结构的源码实现（实际上还有一种称作skiplist的结构...
【笔记】TypeError: unsupported operand type(s) for -: ‘list‘ and ‘list‘ 问题解决
nyist_yangguang的博客
01-14 4399
近日 python 入门写了个函数，先建立两个数组 y 和 t ，在另一个头文件中定义了一个计算函数，带有 y-t 等运算。数组我是这样建立的： t=[0,0,1,0] y1=[0.1,0.05,0.6,0,0.05] 结果显示错误： TypeError: unsupported operand type(s) for -: ‘list’ and ‘list’ 这是说 y 和 t 不能做 y-t 运算 才疏学浅，半天才明白是因为，不能直接用 t=[…]，这样建立的是 list 类型。 所..
Redis开源代码读书笔记九（Object模块）
lida2003的专栏
04-07 655
Object功能特性 ==》支持REDIS_STRING、REDIS_LIST、REDIS_SET、REDIS_ZSET、REDIS_HASH对象类型 ==》支持对象引用计数 ==》支持对象内存优化 ==》支持对象比较，复制，获取对象值等操作 ==》支持LRU算法 /* Object types */ #define REDIS_STRING 0 #define REDIS_L
漫话Redis源码之七
认知 行动 坚持
11-21 419
void getrangeCommand(client *c) { robj *o; long long start, end; char *str, llbuf[32]; size_t strlen; if (getLongLongFromObjectOrReply(c,c->argv[2],&start,NULL) != C_OK) return; if (getLongLongFromObjectOrReply(...
redis学习笔记（11）---字符串命令及实现
qinm的专栏
05-09 2161
对象类型与编码方式　　　　对于字符串类型的命令，redis数据库会为每个对象创建一个字符串类型（REDIS_STRING）的对象。 　　对于字符串类型的对象，可以支持三种编码方式：#define REDIS_ENCODING_RAW 0 /* Raw representation */ #define REDIS_ENCODING_INT 1 /* Encoded as integ
Redis List 数据类型详解与操作命令
"Redis List类型是一种有序的字符串链表数据结构，用于实现数据队列操作。它可以高效地在两端（头部或尾部）进行插入和删除操作，但对链表中间元素的操作效率较低。Redis提供了多种操作List的命令，如LPUSH、LPUSHX...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值