Redis 设计与实现（第九章） -- 数据库

概述

---

1.数据库结构

2.数据库键空间

3.键生存时间

4.持久化对过期键处理

5.数据库通知

1.数据库结构

Redis服务器将所有server状态都保存在数据结构中的db数组，服务器会根据dbnum来决定创建多个个数据库，默认为16个。

struct redisServer {  //数据结构里面有很多属性，这里只取了相关的两个来说明
    /* General */
    redisDb *db;
    int dbnum; 
}redisServer;

创建db后，如下所示：

同样的在redisClient的数据结构中，也有一个指向当前db的属性，当在客户端执行select x时，指针就会指向对应的db

typedef struct redisClient {
    redisDb *db;
}redisClient;

如下图所示，客户端选择db 2的时的结构图：

2.数据库键空间

Redis是一个键值对数据库，数据库的所有键值对都保存在字典中，可以看下redisDb的数据结构中，有个dict的属性，称这个字典属性为键空间；

typedef struct redisDb {
    dict *dict;                 /* The keyspace for this DB */
    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 */
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    struct evictionPoolEntry *eviction_pool;    /* Eviction pool of keys */
    int id;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
} redisDb;

键空间和用户所见的数据库是对应的，比如set msg aaa，对应每个键都是一个字符串对象，每个值可以为字符串对象、列表对象、hash表对象、集合对象等；

比如在客户端命令中，设置几个key对象，一个字符串，一个列表，一个哈希表，如下：

127.0.0.1:6379[12]> set msg 1

OK

127.0.0.1:6379[12]> rpush list "a" "b" "c"

(integer) 3

127.0.0.1:6379[12]> hset book author "Jony"

(integer) 1

127.0.0.1:6379[12]> hset book name "c++"

对应的关系如下：

读写键空间的时候，还有一些其他的维护操作，比如：

1.在读取一个键后（读和写都要读取键空间），服务器会根据键是否存在来更新键空间命中或未命中的次数，可以通过info stats命令查看；

keyspace_hits:12322422

keyspace_misses:1843426

2.在读取一个键后，服务器会更新这个键的LRU（最后一次使用时间），使用object idletime key可以查看这个key的空闲时间，前面章节有讲到过；

3.服务器读取的时候，如果发现key已经过期，则会先删除这个key，再执行余下操作；

4.如果有客户端使用WATCH 命令监视了某个键，服务器会在这个键被修改后，将这个键表尾dirty，从而让事务程序意识到这个键已经被修改了；

5.服务器每次修改一次键，就会将dirty数+1，这个键会触发服务器的持久化及复制操作；

6.如果服务器开启了数据库通知功能，则会在键被修改后，按照配置发送相应的数据库通知。

3.键的生存时间

在Redis中可以通过expire来设置键的过期时间，我们也可以通过ttl key命令来查看键的过期时间。具体是怎样实现的？如果保存的？如何超时的？接下来会分段来讲解。

设置超时

可以通过四种命令来设置key的过期时间：

expire key ttl：设置key的过期时间为ttl秒

pexpire key ttl：设置key的过期时间为ttl毫秒

expireat key timestamp：设置key的过期时间为timestamp所指定的秒数时间戳

pexpireat key timestamp：设置key的过期时间为timestamp所指定的毫秒数时间戳

这个不多说了，四个命令大体类似，最终执行结果和pexpireat一样；

保存过期时间

怎么保存的呢？ 看下redisDb的数据结构，有个expires的dict来保存过期的键值对：

typedef struct redisDb {
    dict *dict;                 /* The keyspace for this DB */
    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 */
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    struct evictionPoolEntry *eviction_pool;    /* Eviction pool of keys */
    int id;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
} redisDb;

dict的键为指向键空间的某个键对象，值为超时时间，比如为某个key通过expire设置了超时时间，那么保存结构如下（键空间的地址其实只有一个），保存的为时间戳：

移除过期时间

通过persist key来移除key的超时时间，即将key对应的键值对从expires字典中移除

返回剩余生存时间

通常通过ttl或者pttl来获取key的剩余生存时间，具体实现为过期时间减去当前时间时间戳

过期键的判断

如果不通过ttl来返回剩余时间，就时间访问expires的dict字典：

1.先检查key是否在expires字典中存在；如果存在则获取时间；

2.获取unix的当前时间戳，如果大于过期时间的话，则过期，否则未过期；

过期键的删除

这个也是面试中比较常问的，给redis键设置超时时间后，到期后怎么就自动删除了？

Redis的删除机制，理论上来将可以有如下考虑：

1.设置定时机制

在给键设置过期时间的时候，同时设置一个定时器，定时器到期后，自动删除；这样做的优点是可以保存过期键能够及时被删除，并释放占用的内存；但是缺点也比较明显，当大量的键存在的时候，对cpu消耗会比较大，这样回导致无法响应正常的请求；

2.惰性删除

key到期后，不去删除它，当需要取key的时候，先获取过期时间，如果超时了，则先删除再进行下一步处理。这样对cpu是最友好的，但是会占用内存，如果过期key比较多，又没有程序使用这些key的话，就会一直占着内存。

3.定期删除

前面两种策略要不就是耗CPU，要不就是耗内存。定期删除每隔一段时间执行过期键的删除操作，并通过限制删除操作执行的时长和频率来减少对cpu的影响。定期删除极大的减少了内存浪费的情况。那定期删除以什么频率和执行时间来操作呢？

redis中过期键的删除策略

redis中采用的删除策略为惰性删除和定期删除两种，配合这两种策略，服务器可以很好的在使用cpu时间和避免内存浪费之间取得平衡。

惰性删除的实现

所有对数据库的读写命令执行之前都会先调用expireIfNeed函数来判断是否超时，具体代码如下：

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 */

    /* Don't expire anything while loading. It will be done later. */
    if (server.loading) return 0;

    /* If we are in the context of a Lua script, we claim that time is
     * blocked to when the Lua script started. This way a key can expire
     * only the first time it is accessed and not in the middle of the
     * script execution, making propagation to slaves / AOF consistent.
     * See issue #1525 on Github for more information. */
    now = server.lua_caller ? server.lua_time_start : mstime();

    /* If we are running in the context of a slave, return ASAP:
     * the slave key expiration is controlled by the master that will
     * send us synthesized DEL operations for expired keys.
     *
     * Still we try to return the right information to the caller,
     * that is, 0 if we think the key should be still valid, 1 if
     * we think the key is expired at this time. */
    if (server.masterhost != NULL) return now > when;

    /* Return when this key has not expired */
    if (now <= when) return 0;

    /* Delete the key */
    server.stat_expiredkeys++;
    propagateExpire(db,key);
    notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED,
        "expired",key,db->id);
    return dbDelete(db,key);
}

执行流程如下：

定期删除的实现

通过activeExpireCycle函数来实现，该函数会分多次遍历服务器中的各个数据库，从数据库的expires字典中随机取出一部分键的过期时间，并删除其中的过期键；

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. */

    int j, iteration = 0;
    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. */
        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:
     *
     * 1) Don't test more DBs than we have.
     * 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. */
    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; /* in microseconds. */

    for (j = 0; j < dbs_per_call; j++) {
        int expired;
        redisDb *db = server.db+(current_db % server.dbnum);  //从0db开始，依次往上

        /* 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. */
        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. */
            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. */
            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_sum = 0;
            ttl_samples = 0;

            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;

            while (num--) {
                dictEntry *de;
                long long ttl;

                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                ttl = dictGetSignedIntegerVal(de)-now;
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl < 0) ttl = 0;
                ttl_sum += ttl;
                ttl_samples++;
            }

            /* Update the average TTL stats for this database. */
            if (ttl_samples) {
                long long avg_ttl = ttl_sum/ttl_samples;

                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                /* Smooth the value averaging with the previous one. */
                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++;
            if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
                long long elapsed = ustime()-start;

                latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);
                if (elapsed > timelimit) 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. */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);  //循环，如果过期键超过25%
    }
}

该函数怎么调用？  会有个serverCron，默认100ms一次，serverCron会调用databaseCron，databaseCron会调用这个函数进行定期删除key

4.持久化对过期键处理

对于RBD文件，在执行SAVE或BGSAVE命令时，对过期的键不会进行保存到RBD文件中。同理在恢复时，程序会对键的过期时间进行检查，如果过期则不会载入到数据库。

对于AOF文件，如果某个键已经过期，但是还没有到定期删除和惰性删除，对AOF文件没有任何影响。因为当键执行定期删除或惰性删除后，程序会往AOF中追加一个DEL命令。来显示记录该键已经被删除。

在执行AOF重写时，不会将过期的键保存到重写后的AOF文件中。

5.数据库通知

当客户端有订阅某个key时，数据库通知可以在key发生变化时，通知给key的订阅者。