Redis数据库

Redis数据库

 

1.Redis服务器

Redis服务器将所有数据库都保存在服务器状态server.h/redisServer结构的db数组中，db数组的每个项都是一个server.h/redisDb结构，每个redisDb结构代表一个数据库：

struct redisServer {
    // ...
    //
    一个数组，保存着服务器中的所有数据库
    redisDb *db;
    // ...
   //服务器的数据库数量
    int dbnum;
};

dbnum属性的值由服务器配置的database选项决定，默认情况下，该选项的值为16，所以Redis服务器默认会创建16个数据库。

默认情况下，Redis客户端的目标数据库为0号数据库，但客户端可以通过执行SELECT命令来切换目标数据库。

 

2.Redis客户端

在服务器内部，客户端状态redisClient结构的db属性记录了客户端当前的目标数据库，这个属性是一个指向redisDb结构的指针：

typedef struct redisClient {
// ...
//记录客户端当前正在使用的数据库
redisDb *db;
// ...
} redisClient;

3.Redis数据库

typedef struct redisDb {
    dict *dict;                   /* 当前数据库的键空间 */
    dict *expires;              　　/* 键的过期时间 */
    dict *blocking_keys;    /* 处于阻塞状态的键和相应的client（主要用于List类型的阻塞操作）*/
    dict *ready_keys;        /* 准备好数据可以解除阻塞状态的键和相应的client */
    dict *watched_keys;     /* 被watch命令监控的key和相应client */
    int id;                          /* 数据库ID标识 */
    long long avg_ttl;         /* 数据库内所有键的平均TTL（生存时间） */
    list *defrag_later;         /*逐一尝试整理碎片的关键名称列表 */
} redisDb;

redisDb结构的dict字典保存了数据库中的所有键值对，我们将这个字典称为键空间(key space) 键空间和用户所见的数据库是直接对应的：

❑键空间的键也就是数据库的键，每个键都是一个字符串对象。

❑键空间的值也就是数据库的值，每个值可以是字符串对象、列表对象、哈希表对象、集合对象和有序集合对象中的任意一种Redis对象。

4.Redis键过期时间和过期时间查询TTL

通过EXPIRE命令或者PEXPIRE命令，客户端可以以秒或者毫秒精度为数据库中的某个键设置生存时间（Time To Live，TTL），在经过指定的秒数或者毫秒数之后，服务器就会自动删除生存时间为0的键。

expires字段也是一个字典dict结构，字典的键为key，值为该key对应的过期时间，过期时间为long long类型整数，是以毫秒为单位的过期 UNIX 时间戳。setExpire函数的作用是为指定key设置过期时间。

/* 为指定key设置过期时间 */
void setExpire(redisDb *db, robj *key, long long when) {
    dictEntry *kde, *de;

    /* Reuse the sds from the main dict in the expire dict */
    // db->dict和db->expires是共用key字符串对象的
    // 取出key
    kde = dictFind(db->dict,key->ptr);
    redisAssertWithInfo(NULL,key,kde != NULL);
    // 取出过期时间
    de = dictReplaceRaw(db->expires,dictGetKey(kde));
    // 重置key的过期时间
    dictSetSignedIntegerVal(de,when);
}

有了过期时间戳我们就很容易判断某个key是否过期：只要将当前时间戳跟过期时间戳比较一下即可，如果当前时间戳大于过期时间戳显然该key已经过期了。

在Redis中，如果没有为一个key设置过期时间，那么该key就不会出现在db->expires字典中。也就是说db->expires字段只保存了设置有过期时间的key。

• 设置过期时间

Redis有四个不同的命令可以用于设置键的生存时间（键可以存在多久）或过期时间（键什么时候会被删除）：（expire.c中）

　　❑EXPIRE＜key＞＜ttl＞命令用于将键key的生存时间设置为ttl秒。

　　❑PEXPIRE＜key＞＜ttl＞命令用于将键key的生存时间设置为ttl毫秒。

　　❑EXPIREAT＜key＞＜timestamp＞命令用于将键key的过期时间设置为timestamp所指定的秒数时间戳。

　　❑PEXPIREAT＜key＞＜timestamp＞命令用于将键key的过期时间设置为timestamp所指定的毫秒数时间戳。

EXPIREAT命令与EXPIRE命令的差别在于前者使用Unix时间作为第二个参数表示键的生存时间的截止时间。PEXPIREAT命令与EXPIREAT命令的区别是前者的时间单位是毫秒。

虽然有多种不同单位和不同形式的设置命令，但实际上EXPIRE、PEXPIRE、EXPIREAT三个命令都是使用PEXPIREAT命令来实现的：无论客户端执行的是以上四个命令中的哪一个，经过转换之后，最终的执行效果都和执行PEXPIREAT命令一样。

/* EXPIRE key seconds */
void expireCommand(client *c) {
    expireGenericCommand(c,mstime(),UNIT_SECONDS);
}

/* EXPIREAT key time */
void expireatCommand(client *c) {
    expireGenericCommand(c,0,UNIT_SECONDS);
}

/* PEXPIRE key milliseconds */
void pexpireCommand(client *c) {
    expireGenericCommand(c,mstime(),UNIT_MILLISECONDS);
}

/* PEXPIREAT key ms_time */
void pexpireatCommand(client *c) {
    expireGenericCommand(c,0,UNIT_MILLISECONDS);
}


void expireGenericCommand(redisClient *c, long long basetime, int unit) {
    robj *key = c->argv[1], *param = c->argv[2];
    // 以毫秒为单位的unix时间戳
    long long when;    // 获取过期时间
    if (getLongLongFromObjectOrReply(c, param, &when, NULL) != REDIS_OK)
        return;

    // 如果传入的过期时间是以秒为单位，则转换为毫秒为单位
    if (unit == UNIT_SECONDS) when *= 1000;
    // 加上basetime得到过期时间戳
    when += basetime;

    /* No key, return zero. */
    // 取出key，如果该key不存在直接返回
    if (lookupKeyRead(c->db,key) == NULL) {
        addReply(c,shared.czero);
        return;
    }
    if (when <= mstime() && !server.loading && !server.masterhost) {
        // 如果when指定的时间已经过期，而且当前为服务器的主节点，并且目前没有载入数据
        robj *aux;
        redisAssertWithInfo(c,key,dbDelete(c->db,key));
        server.dirty++;
        // 传播一个显式的DEL命令
        aux = createStringObject("DEL",3);
        rewriteClientCommandVector(c,2,aux,key);
        decrRefCount(aux);
        signalModifiedKey(c->db,key);
        notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",key,c->db->id);
        addReply(c, shared.cone);
        return;
    } else {
        // 设置key的过期时间（when提供的时间可能已经过期）
        setExpire(c->db,key,when);
        addReply(c,shared.cone);
        signalModifiedKey(c->db,key);                  notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"expire",key,c->db->id);
        server.dirty++;
        return;
    }
}

• TTL命令

TTL命令以秒为单位返回键的剩余生存时间，而PTTL命令则以毫秒为单位返回键的剩余生存时间

/* TTL key */
void ttlCommand(client *c) {
    ttlGenericCommand(c, 0);
}

/* PTTL key */
void pttlCommand(client *c) {
    ttlGenericCommand(c, 1);
}

void ttlGenericCommand(client *c, int output_ms) {
    long long expire, ttl = -1;

    /* 如果这个键不存在 return -2 */
    if (lookupKeyReadWithFlags(c->db,c->argv[1],LOOKUP_NOTOUCH) == NULL) {
        addReplyLongLong(c,-2);
        return;
    }
    /* 键存在. Return -1 if 已经过期, or the 实际的TTL值otherwise. */
    expire = getExpire(c->db,c->argv[1]);
    if (expire != -1) {
        ttl = expire-mstime();
        if (ttl < 0) ttl = 0;
    }
    if (ttl == -1) {
        addReplyLongLong(c,-1);
    } else {
        addReplyLongLong(c,output_ms ? ttl : ((ttl+500)/1000));
    }
}

• 过期键删除策略

如果一个键过期了，那么它什么时候会被删除呢？这个问题有三种可能的答案，它们分别代表了三种不同的删除策略：

　　❑定时删除：在设置键的过期时间的同时，创建一个定时器（timer），让定时器在键的过期时间来临时，立即执行对键的删除操作。

　　❑惰性删除：放任键过期不管，但是每次从键空间中获取键时，都检查取得的键是否过期，如果过期的话，就删除该键；如果没有过期，就返回该键。

　　❑定期删除：每隔一段时间，程序就对数据库进行一次检查，删除里面的过期键。至于要删除多少过期键，以及要检查多少个数据库，则由算法决定。

在这三种策略中，第一种和第三种为主动删除策略，而第二种则为被动删除策略。

1）过期键的惰性删除策略由db.c/expireIfNeeded函数实现，所有读写数据库的Redis命令在执行之前都会调用expireIfNeeded函数对输入键进行检查：

　　❑如果输入键已经过期，那么expireIfNeeded函数将输入键从数据库中删除。

　　❑如果输入键未过期，那么expireIfNeeded函数不做动作。

对于过期的key，Redis负责将该key删除，为了提高运行效率，Redis采取这么一种处理方式：只有当真正要访问该key时才检查该key是否过期。如果过期就删除，如果没过期就正常访问。通常我们把这种只有在访问时才检查过期的策略叫做“惰性删除”。

int expireIfNeeded(redisDb *db, robj *key) {
    // 获取key的过期时间
    mstime_t when = getExpire(db,key);
    mstime_t now;

    // 如果该key没有过期时间，返回0
　　if (when < 0) return 0; 

    // 如果服务器正在加载操作中，则不进行过期检查，返回0
　　if (server.loading) return 0;

    //如果我们处在Lua脚本的上下文中，我们假设直到Lua脚本启动时间不变的。 
    //通过这种方式，key只能在第一次访问而不是在脚本执行过程中过期，
    //从而使slave/AOF传播一致。
　　now = server.lua_caller ? server.lua_time_start : mstime();

    // 如果当前程序运行在slave节点，该key的过期操作是由master节点控制的（master节点会发出DEL操作）
    // 在这种情况下该函数先返回一个正确值，即如果key未过期返回0，否则返回1。
    // 真正的删除操作等待master节点发来的DEL命令后再执行
    if (server.masterhost != NULL) return now > when;

    // 如果未过期，返回0
    if (now <= when) return 0;

    // 如果已过期，删除该key
    server.stat_expiredkeys++;
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) : dbSyncDelete(db,key);
}

对于过期key，Redis主（master）节点和附属（slave）节点有不同的处理策略，具体如下：

如果当前Redis服务器是主节点，即if (server.masterhost != NULL)语句判断为false，那么当它发现一个过期key后，会调用propagateExpire函数向所有附属节点发送一个 DEL 命令，然后再删除该key。这种做法使得对key的过期操作可以集中在一个地方处理。

如果当前Redis服务器是附属节点，即if (server.masterhost != NULL)语句判断为true，那么它立即向程序返回该key是否已经过期的信息。即便该key已经过期也不会真正的删除该key。直到该节点接到从主节点发来的DEL 命令之后，才会真正执行删除操作。

当Redis从数据库db中取出指定key的对象时，总是先调用调用expireIfNeeded函数来检查对应key是否过期，然后再从数据库中查找对象。

robj *lookupKeyRead(redisDb *db, robj *key) {
    return lookupKeyReadWithFlags(db,key,LOOKUP_NONE);
}

robj *lookupKeyReadWithFlags (redisDb *db, robj *key, int flags) {
    robj *val;
    // 如果key已过期，删除该key
    if (expireIfNeeded(db,key) == 1) {
        /*密钥过期, 如果当前为master，expireIfNeeded（），仅当密钥不存在时才返回0，所以它很安全，尽快返回NULL*/
        if (server.masterhost == NULL) return NULL;

        /* 如果当前处于slave节点，expireIfNeeded只返回信息*/
        if (server.current_client &&
            server.current_client != server.master &&
            server.current_client->cmd &&
            server.current_client->cmd->flags & CMD_READONLY)
        {
            return NULL;
        }
}    
// 从数据库db中找到指定key的对象
    val = lookupKey(db,key, flags);
    if (val == NULL)
        // 更新“未命中”次数
        server.stat_keyspace_misses++;
    else
        // 更新“命中”次数
        server.stat_keyspace_hits++;
    return val;
}

/*  该函数是为写操作而从数据库db中取出指定key的对象。
    如果敢函数执行成功则返回目标对象，否则返回NULL。*/
robj *lookupKeyWrite(redisDb *db, robj *key) {
    // 如果key已过期，删除该key
expireIfNeeded(db,key);
// 从数据库db中找到指定key的对象
    return lookupKey(db,key,LOOKUP_NONE);
}

2）过期键的定期删除策略由expire.c/activeExpireCycle函数实现，周期性过期是通过周期心跳函数（serverCron）来触发的，每当Redis的服务器周期性操作serverCron函数执行时，activeExpireCycle函数就会被调用，它在规定的时间内，分多次遍历服务器中的各个数据库，从数据库的expires字典中随机检查一部分键的过期时间，并删除其中的过期键。

//周期性操作中进行慢速过期键删除，执行频率同databasesCron的执行频率  
//执行时长为1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100  
void databasesCron(void) {  
    if (server.active_expire_enabled && server.masterhost == NULL) {  
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);  
    } else if (server.masterhost != NULL) {  
        expireSlaveKeys();  
    }  
}//进行快速过期键删除，执行间隔和执行时长都为ACTIVE_EXPIRE_CYCLE_FAST_DURATION  
void beforeSleep(struct aeEventLoop *eventLoop) {  
    if (server.active_expire_enabled && server.masterhost == NULL)  
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);  
}  

void activeExpireCycle(int type) {
　　static unsigned int current_db = 0; /* 上次定期删除遍历到的数据库id*/
　　static int timelimit_exit = 0;      /* Time limit hit in previous call? */
　　static long long last_fast_cycle = 0; /* 上一次执行快速定期删除的时间点 */

　　int j, iteration = 0;
　　int dbs_per_call = CRON_DBS_PER_CALL;//每次定期删除，遍历的数据库的数量
　　long long start = ustime(), timelimit;

　　/*当客户端暂停时，数据集应该是静态的，不仅仅客户端的命令无法写入的，而且key到期的指令无法执行*/
　　if (clientsArePaused()) return;

　　if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        if (!timelimit_exit) return;
        //快速定期删除的时间间隔是ACTIVE_EXPIRE_CYCLE_FAST_DURATION
        //ACTIVE_EXPIRE_CYCLE_FAST_DURATION是快速定期删除的执行时长
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
        last_fast_cycle = start;
　　}

　　//我们通常应该每次迭代测试CRON_DBS_PER_CALL
　　if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;

    //慢速定期删除的执行时长
    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
    timelimit_exit = 0;
    if (timelimit <= 0) timelimit = 1;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /*删除操作的执行时长 */

    //当我们将密钥过期时，累积一些全局统计信息，以了解已经逻辑过期但仍存在于数据库内的密钥数量。
　　long total_sampled = 0;
　　long total_expired = 0;
　　
　　for (j = 0; j < dbs_per_call; j++) {
　　　　int expired;
　　　　redisDb *db = server.db+(current_db % server.dbnum);
　　　　current_db++;
　　　　do {
　　　　　　unsigned long num, slots;
　　　　　　long long now, ttl_sum;
　　　　　　int ttl_samples;
　　　　　　iteration++;

　　　　　　//如果没有要删除的键就转向下一个数据库
　　　　　　if ((num = dictSize(db->expires)) == 0) {
　　　　　　　　db->avg_ttl = 0;
　　　　　　　　break;
　　　　　　}
　　　　　　slots = dictSlots(db->expires);
　　　　　　now = mstime();

　　　　　　//当槽的填充小于1%，key显得很重要，因此会等待更好的时机进行键清除。
　　　　　　if (num && slots > DICT_HT_INITIAL_SIZE && (num*100/slots < 1)) break;
　　　　}
　　}
　　expired = 0;
　　ttl_sum = 0;
　　ttl_samples = 0;

　　//在每个数据库中检查的键的数量
　　if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
　　　　num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
　　//从db->expires中随机选取num个键进行检查
　　while (num--) {
　　　　if ((de = dictGetRandomKey(db->expires)) == NULL) break;
　　　　　　ttl = dictGetSignedIntegerVal(de)-now;
　　　　　　//过期检查，并对过期键进行删除
　　　　　　if (activeExpireCycleTryExpire(db,de,now)) expired++;
　　　　　　　　if (ttl > 0) {
　　　　　　　　/* We want the average TTL of keys yet not expired. */
             ttl_sum += ttl;
                    ttl_samples++;
                }
                total_sampled++;           
            }

　　　　　　//更新平均过期时间
          if (ttl_samples) {
                long long avg_ttl = ttl_sum/ttl_samples;

                //用几个样本做一个简单的运行平均值。我们只使用当前的估计值，权重为2％和以前的估计98％的权重。
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
　　　　　　}

　　　　　　//即使有很多密钥过期，我们也不能永远阻止。 因此，给定的毫秒数量返回给调用者，等待另一个活动的过期周期。
　　　　　　if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
　　　　　　　　elapsed = ustime()-start;
　　　　　　　　if (elapsed > timelimit) {
　　　　　　　　　　timelimit_exit = 1;
　　　　　　　　　　server.stat_expired_time_cap_reached_count++;
　　　　　　　　　　break;
　　　　　　　　}
　　　　　　}
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4); //每次检查只删除ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4个过期键
    }
}

 activeExpireCycle函数的工作模式可以总结如下：

❑函数每次运行时，都从一定数量的数据库中取出一定数量的随机键进行检查，并删除其中的过期键。

❑全局变量current_db会记录当前activeExpireCycle函数检查的进度，并在下一次activeExpireCycle函数调用时，接着上一次的进度进行处理。比如说，如果当前activeExpireCycle函数在遍历10号数据库时返回了，那么下次activeExpireCycle函数执行时，将从11号数据库开始查找并删除过期键。

❑随着activeExpireCycle函数的不断执行，服务器中的所有数据库都会被检查一遍，这时函数将current_db变量重置为0，然后再次开始新一轮的检查工作。

总结：

❑Redis服务器的所有数据库都保存在redisServer.db数组中，而数据库的数量则由redisServer.dbnum属性保存。

❑客户端通过修改目标数据库指针，让它指向redisServer.db数组中的不同元素来切换不同的数据库。

❑数据库主要由dict和expires两个字典构成，其中dict字典负责保存键值对，而expires字典则负责保存键的过期时间。

❑因为数据库由字典构成，所以对数据库的操作都是建立在字典操作之上的。

❑数据库的键总是一个字符串对象，而值则可以是任意一种Redis对象类型，包括字符串对象、哈希表对象、集合对象、列表对象和有序集合对象，分别对应字符串键、哈希表键、集合键、列表键和有序集合键。

❑expires字典的键指向数据库中的某个键，而值则记录了数据库键的过期时间，过期时间是一个以毫秒为单位的UNIX时间戳。

❑Redis使用惰性删除和定期删除两种策略来删除过期的键：惰性删除策略只在碰到过期键时才进行删除操作，定期删除策略则每隔一段时间主动查找并删除过期键。

❑执行SAVE命令或者BGSAVE命令所产生的新RDB文件不会包含已经过期的键。

❑执行BGREWRITEAOF命令所产生的重写AOF文件不会包含已经过期的键。

❑当一个过期键被删除之后，服务器会追加一条DEL命令到现有AOF文件的末尾，显式地删除过期键。

❑当主服务器删除一个过期键之后，它会向所有从服务器发送一条DEL命令，显式地删除过期键。

❑从服务器即使发现过期键也不会自作主张地删除它，而是等待主节点发来DEL命令，这种统一、中心化的过期键删除策略可以保证主从服务器数据的一致性。

❑当Redis命令对数据库进行修改之后，服务器会根据配置向客户端发送数据库通知。