在关系型数据库如MySQL，数据库数据是按照行记录格式进行存储的。同理，我们常说Redis是一个键值对（Key-Value）构成的内存数据库，具体是以什么形式进行存储的，下面通过源码一看究竟。

数据结构

typedef struct redisDb {

   // 数据库键空间，保存着数据库中的所有键值对

   dict *dict;                 /* The keyspace for this DB */

   // 键的过期时间，字典的键为键，字典的值为过期事件 UNIX 时间戳

   dict *expires;              /* Timeout of keys with a timeout set */

   // 正处于阻塞状态的键

   dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP) */

   // 可以解除阻塞的键

   dict *ready_keys;           /* Blocked keys that received a PUSH */

   // 正在被 WATCH 命令监视的键

   dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */

   struct evictionPoolEntry *eviction_pool;    /* Eviction pool of keys */

   // 数据库号码

   int id;                     /* Database ID */

   // 数据库的键的平均 TTL ，统计信息

   long long avg_ttl;          /* Average TTL, just for stats */

} redisDb;

• dict  以字典表数据结构存储真实的数据库数据
• expires 以字典表数据结构存储的所有数据库键Key的过期时间数据

数据存储

• 键Key 每个键都是一个字符串对象
• 值Value 每个值可以是字符串对象、列表对象、哈希对象、集合对象、有序集合对象的任意一种

数据查找

数据过期

惰性删除

/*

* 检查 key 是否已经过期，如果是的话，将它从数据库中删除。

* 返回 0 表示键没有过期时间，或者键未过期。

* 返回 1 表示键已经因为过期而被删除了。

*/

int expireIfNeeded(redisDb *db, robj *key) {

   // 取出键的过期时间

   mstime_t when = getExpire(db,key);

   mstime_t now;

   // 没有过期时间

   if (when < 0) return 0; /* No expire for this key */

   // 如果服务器正在进行载入，那么不进行任何过期检查

   if (server.loading) return 0;

   now = server.lua_caller ? server.lua_time_start : mstime();

   // 当服务器运行在 replication 模式时

   // 附属节点并不主动删除 key

   // 它只返回一个逻辑上正确的返回值

   // 真正的删除操作要等待主节点发来删除命令时才执行

   // 从而保证数据的同步

   if (server.masterhost != NULL) return now > when;

   // 运行到这里，表示键带有过期时间，并且服务器为主节点

   /* Return when this key has not expired */

   // 如果未过期，返回 0

   if (now <= when) return 0;

   /* Delete the key */

   server.stat_expiredkeys++;

   // 向 AOF 文件和附属节点传播过期信息

   propagateExpire(db,key);

   // 发送事件通知

   notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED,

       "expired",key,db->id);

   // 将过期键从数据库中删除

   return dbDelete(db,key);

}

定期删除

• 快模式 通过模式设定来计算函数超时时间，在快模式下默认为1000微妙，否则根据25%的CPU执行时间设置
• 处理数量 数据库一般初始化16个，这里也会默认处理16个进行全扫描，在每个数据库redisdb的expires这个字典表中随机获取20个进行检查
• 处理停止 当函数执行超时或已删除的过期键占当前总数据库带过期时间的键数量的25%则停止

void activeExpireCycle(int type) {

   /* This function has some global state in order to continue the work

    * incrementally across calls. */

   // 静态变量，用来累积函数连续执行时的数据

   static unsigned int current_db = 0; /* Last DB tested. */

   static int timelimit_exit = 0;      /* Time limit hit in previous call? */

   static long long last_fast_cycle = 0; /* When last fast cycle ran. */

   unsigned int j, iteration = 0;

   // 默认每次处理的数据库数量

   unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL;

   // 函数开始的时间

   long long start = ustime(), timelimit;

   // 快速模式

   if (type == ACTIVE_EXPIRE_CYCLE_FAST) {

       /* Don't start a fast cycle if the previous cycle did not exited

        * for time limt. Also don't repeat a fast cycle for the same period

        * as the fast cycle total duration itself. */

       // 如果上次函数没有触发 timelimit_exit ，那么不执行处理

       if (!timelimit_exit) return;

       // 如果距离上次执行未够一定时间，那么不执行处理

       if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;

       // 运行到这里，说明执行快速处理，记录当前时间

       last_fast_cycle = start;

   }

   /* We usually should test REDIS_DBCRON_DBS_PER_CALL per iteration, with

    * two exceptions:

    *

    * 一般情况下，函数只处理 REDIS_DBCRON_DBS_PER_CALL 个数据库，

    * 除非：

    *

    * 1) Don't test more DBs than we have.

    *    当前数据库的数量小于 REDIS_DBCRON_DBS_PER_CALL

    * 2) If last time we hit the time limit, we want to scan all DBs

    * in this iteration, as there is work to do in some DB and we don't want

    * expired keys to use memory for too much time.

    *     如果上次处理遇到了时间上限，那么这次需要对所有数据库进行扫描，

    *     这可以避免过多的过期键占用空间

    */

   if (dbs_per_call > server.dbnum || timelimit_exit)

       dbs_per_call = server.dbnum;

   /* We can use at max ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC percentage of CPU time

    * per iteration. Since this function gets called with a frequency of

    * server.hz times per second, the following is the max amount of

    * microseconds we can spend in this function. */

   // 函数处理的微秒时间上限

   // ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 默认为 25 ，也即是 25 % 的 CPU 时间

   timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;

   timelimit_exit = 0;

   if (timelimit <= 0) timelimit = 1;

   // 如果是运行在快速模式之下

   // 那么最多只能运行 FAST_DURATION 微秒

   // 默认值为 1000 （微秒）

   if (type == ACTIVE_EXPIRE_CYCLE_FAST)

       timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */

   // 遍历数据库

   for (j = 0; j < dbs_per_call; j++) {

       int expired;

       // 指向要处理的数据库

       redisDb *db = server.db+(current_db % server.dbnum);

       /* Increment the DB now so we are sure if we run out of time

        * in the current DB we'll restart from the next. This allows to

        * distribute the time evenly across DBs. */

       // 为 DB 计数器加一，如果进入 do 循环之后因为超时而跳出

       // 那么下次会直接从下个 DB 开始处理

       current_db++;

       /* Continue to expire if at the end of the cycle more than 25%

        * of the keys were expired. */

       do {

           unsigned long num, slots;

           long long now, ttl_sum;

           int ttl_samples;

           /* If there is nothing to expire try next DB ASAP. */

           // 获取数据库中带过期时间的键的数量

           // 如果该数量为 0 ，直接跳过这个数据库

           if ((num = dictSize(db->expires)) == 0) {

               db->avg_ttl = 0;

               break;

           }

           // 获取数据库中键值对的数量

           slots = dictSlots(db->expires);

           // 当前时间

           now = mstime();

           /* When there are less than 1% filled slots getting random

            * keys is expensive, so stop here waiting for better times...

            * The dictionary will be resized asap. */

           // 这个数据库的使用率低于 1% ，扫描起来太费力了（大部分都会 MISS）

           // 跳过，等待字典收缩程序运行

           if (num && slots > DICT_HT_INITIAL_SIZE &&

               (num*100/slots < 1)) break;

           /* The main collection cycle. Sample random keys among keys

            * with an expire set, checking for expired ones.

            *

            * 样本计数器

            */

           // 已处理过期键计数器

           expired = 0;

           // 键的总 TTL 计数器

           ttl_sum = 0;

           // 总共处理的键计数器

           ttl_samples = 0;

           // 每次最多只能检查 LOOKUPS_PER_LOOP 个键

           if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)

               num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;

           // 开始遍历数据库

           while (num--) {

               dictEntry *de;

               long long ttl;

               // 从 expires 中随机取出一个带过期时间的键

               if ((de = dictGetRandomKey(db->expires)) == NULL) break;

               // 计算 TTL

               ttl = dictGetSignedIntegerVal(de)-now;

               // 如果键已经过期，那么删除它，并将 expired 计数器增一

               if (activeExpireCycleTryExpire(db,de,now)) expired++;

               if (ttl < 0) ttl = 0;

               // 累积键的 TTL

               ttl_sum += ttl;

               // 累积处理键的个数

               ttl_samples++;

           }

           /* Update the average TTL stats for this database. */

           // 为这个数据库更新平均 TTL 统计数据

           if (ttl_samples) {

               // 计算当前平均值

               long long avg_ttl = ttl_sum/ttl_samples;

               

               // 如果这是第一次设置数据库平均 TTL ，那么进行初始化

               if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;

               /* Smooth the value averaging with the previous one. */

               // 取数据库的上次平均 TTL 和今次平均 TTL 的平均值

               db->avg_ttl = (db->avg_ttl+avg_ttl)/2;

           }

           /* We can't block forever here even if there are many keys to

            * expire. So after a given amount of milliseconds return to the

            * caller waiting for the other active expire cycle. */

           // 我们不能用太长时间处理过期键，

           // 所以这个函数执行一定时间之后就要返回

           // 更新遍历次数

           iteration++;

           // 每遍历 16 次执行一次

           if ((iteration & 0xf) == 0 && /* check once every 16 iterations. */

               (ustime()-start) > timelimit)

           {

               // 如果遍历次数正好是 16 的倍数

               // 并且遍历的时间超过了 timelimit

               // 那么断开 timelimit_exit

               timelimit_exit = 1;

           }

           // 已经超时了，返回

           if (timelimit_exit) return;

           /* We don't repeat the cycle if there are less than 25% of keys

            * found expired in the current DB. */

           // 如果已删除的过期键占当前总数据库带过期时间的键数量的 25 %

           // 那么不再遍历

       } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);

   }

}

总结

• Redis根据数据容量采用不同的编码格式、数据结构构建了五种对象类型，我们常说Redis是一个Key-Value型数据库，主要是因为它采用了字典表形式对不同数据类型数据进行了空间构建和存储，充分利用了哈希表快速寻址特点，使得数据查询、处理拥有较高性能，也充分利用字典表rehash特点进行数据底层存储扩容
• 之前介绍过Redis是一个以事件驱动为模型的单线程运行的服务，它定义了时间、文件两种类型事件共同协作在一个单线程环境下工作。键过期维护存储在一个等同于数据存储的字典表中，为了不较大影响Redis处理性能和维护成本，采用了惰性删除和定期删除共存策略，精巧考究的设计能看出作者对性能使用的深度思考以及很多自适应算法的存在，非常值得学习

参考

《Redis设计与实现》