上一篇文章介绍了redis基本的数据结构和对象《redis设计与实现》1-数据结构与对象篇

本文主要关于：

• redis数据库实现的介绍
• 前面介绍的各种数据，在redis服务器中的内存模型是什么样的的。
• RDB文件将这些内存数据持久化后的格式是什么样的
• RDB和AOF序列化的区别是什么
• redis提供什么机制保障AOF文件不会一直增长
• RDB文件转储成json文件和内存分析工具介绍
• 客户端和服务端数据结构介绍

数据库

服务器的数据库

• redis是内存型数据库，所有数据都放在内存中
• 保存这些数据的是redisServer这个结构体，源码中该结构体包括大概300多行的代码。具体参考server.h/redisServer
• 和数据库相关的两个属性是：
  • int类型的dbnum：表示数据库数量，默认16个
  • redisDb指针类型的db：数据库对象数组

    

数据库对象

所在文件为server.h。数据库中所有针对键值对的增删改查，都是对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 */
    int id;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
} redisDb;

• dict：保存了该数据库中所有的键值对，键都是字符串，值可以是多种类型
• expires：保存了该数据中所有设置了过期时间的key
• blocking_keys：保存了客户端阻塞的
• watched_keys：保存被watch的命令
• id：保存数据库索引
• avg_ttl

客户端切换数据库

• 客户端通过select dbnum 命令切换选中的数据库
• 客户端的信息保存在client这个数据结构中，参考server.h/client
• client的类型为redisDb的db指针指向目前所选择的数据库

读写键空间时的其他操作

读写键空间时，是针对dict做操作，但是除了完成基本的增改查找操作，还会执行一些额外的维护操作，包括：

• 读写键时，会根据是否命中，更新hit和miss次数。

  相关命令：info stats keyspace_hits, info stats keyspace_misses

• 读取键后，会更新键的LRU时间，前面章节介绍过该字段
• 读取时，如果发现键已经过期，会先删除该键，然后才执行其他操作
• 如果watch监视了某个键，修改时会标记该键为脏（dirty）
• 每修改一个键，会对脏键计数器加1，触发持久化和复制操作
• 如果开启通知功能，修改键会下发通知

设置过期时间

• expire key ttl：设置生存时间为ttl秒
• pexpire key ttl：设置生存时间为ttl毫秒
• expireat key timestamp：设置过期时间为timstamp的秒数时间戳
• pexpireat key timestamp：过期时间为毫秒时间戳
• persist key：解除过期时间
• ttl key：获取剩余生存时间

保存过期时间

过期时间保存在expires的字典中，值为long类型的毫秒时间戳

过期键删除策略

各种删除策略的对比

策略类型	描述	优点	缺点	redis是否采用
定时删除	通过定时器实现	保证过期键能尽快释放	对cpu不友好，影响相应时间和吞吐量	否
惰性删除	放任不管，查询时才去检查	对cpu友好	没有被访问的永远不会被释放，相当于内存泄露	是
定期删除	每隔一段时间检查	综合前面的优点	难于确定执行时长和频率	是

redis使用的过期键删除策略

redis采用了惰性删除和定期删除策略

惰性删除的实现

• 由db.c中的expireIfNeeded实现
• 每次执行redis命令前都会调用该函数对输入键做检查

定期删除的实现

• server.c中的serverCron函数执行定时任务
• 函数每次运行时，都从一定数量的数据库中取出一定数量的键进行检查，并删除过期键

数据库通知

• 键空间通知：客户端获取数据库中键执行了什么命令。实现代码为notify.c文件的notifyKeyspaceEvent函数

  subscribe __keyspace@0__:keyname
  

• 键事件通知：某个命令被什么键执行了

  subscribe __keyevent@0__:del
  

RDB持久化

• redis是内存数据库，为了避免服务器进程异常导致数据丢失，redis提供了RDB持久化功能
• 持久化后的RDB文件是一个经过压缩的二进制文件

RDB文件的创建与载入

生成rdb文件的两个命令如下，实现函数为rdb.c文件的rdbSave函数：

• SAVE：阻塞redis服务器进程，知道RDB创建完成。阻塞期间不能处理其他请求
• BGSAVE：派生出子进程，子进程负责创建RDB文件，父进程继续处理请求

RDB文件的载入是在服务器启动时自动执行的，实现函数为rdb.c文件的rdbload函数。载入期间服务器一直处于阻塞状态

自动间隔保存

redis允许用户通过设置服务器配置的server选项，让服务器每隔一段时间（100ms）自动执行BGSAVE命令（serverCron函数）

//server.c中main函数内部创建定时器，serverCron为定时任务回调函数
if (aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL) == AE_ERR) {
    serverPanic("Can't create event loop timers.");
    exit(1);
}

配置参数

// 任意一个配置满足即执行
save 900 1 // 900s内，对服务器进行至少1次修改
save 300 10 // 300s内，对服务器至少修改10次

数据结构

// 服务器全局变量，前面介绍过
struct redisServer {
    ...
     /* RDB persistence */
    // 上一次执行save或bgsave后，对数据库进行了多少次修改
    long long dirty;                /* Changes to DB from the last save */
    long long dirty_before_bgsave;  /* Used to restore dirty on failed BGSAVE */
    pid_t rdb_child_pid;            /* PID of RDB saving child */
    struct saveparam *saveparams;   /* Save points array for RDB */
    int saveparamslen;              /* Number of saving points */
    char *rdb_filename;             /* Name of RDB file */
    int rdb_compression;            /* Use compression in RDB? */
    int rdb_checksum;               /* Use RDB checksum? */
    // 上一次成功执行save或bgsave的时间
    time_t lastsave;                /* Unix time of last successful save */
    time_t lastbgsave_try;          /* Unix time of last attempted bgsave */
    time_t rdb_save_time_last;      /* Time used by last RDB save run. */
    time_t rdb_save_time_start;     /* Current RDB save start time. */
    int rdb_bgsave_scheduled;       /* BGSAVE when possible if true. */
    int rdb_child_type;             /* Type of save by active child. */
    int lastbgsave_status;          /* C_OK or C_ERR */
    int stop_writes_on_bgsave_err;  /* Don't allow writes if can't BGSAVE */
    int rdb_pipe_write_result_to_parent; /* RDB pipes used to return the state */
    int rdb_pipe_read_result_from_child; /* of each slave in diskless SYNC. */
    ...
};
// 具体每一个参数对应的变量
struct saveparam {
    time_t seconds;
    int changes;
};

RDB文件结构

概览

• 头五个字符为‘redis’常量，标识这个rdb文件是redis文件
• dv_version：4字节，标识了rdb文件的版本号
• databases：数据库文件内容
• EOF：常量，1字节，标识文件正文结束
• check_sum：8字节无符号整形，保存校验和，判定文件是否有损坏

dababases部分

每个database的内容：

• SELECTDB：常量，1字节。标识了后面的字节为数据库号码
• db_number：数据库号码
• key_value_pairs：数据库的键值对，如果有过期时间，也放在一起。

key_value_pairs部分

不带过期时间的键值对

type为value的类型，1字节，代表对象类型或底层编码，根据type决定如何读取value

带过期时间的键值对

• EXPIRETIME：常量，1字节，表示接下来要读入的是一个以毫秒为单位的过期时间
• ms：8字节长的无符号整形，过期时间

value的编码

每个value保存一个值对象，与type对应。type不同，value的结构，长度也有所不同

字符串对象

• type为REDIS_RDB_TYPE_STRING, value为字符串对象，而字符串对象本身又包含对象的编码和内容
• 如果编码为整数类型，编码后面直接保存整数值

  

• 如果编码为字符串类型，分为压缩和不压缩
  • 如果字符串长度<=20字节，不压缩

    

  • 如果字符串长度>20字节，压缩保存

    

    • REDIS_RDB_ENC_LZF:常量，标识字符串被lzf算法压缩过
    • compressed_len：被压缩后的长度
    • origin_len：字符串原始长度
    • compressed_string：压缩后的内容

列表对象

• type为REDIS_RDB_TYPE_LIST, value为列表对象

  

• list_length：记录列表的长度
• item：以字符串对象来处理

集合对象

• typw为REDIS_RDB_TYPE_SET，value为集合对象

  

• set_size： 集合大小
• elem：以字符串对象来处理

哈希对象

• type为REDIS_RDB_TYPE_HASH, value为哈希对象

  

• hash_size：哈希对象大小
• key-value都以字符串对象处理

有序集合对象

• type为REDIS_RDB_TYPE_ZSET，value为有序集合对象

  

intset编码集合

• type为REDIS_RDB_TYPE_SET_INTSET, value为整数集合对象
• 先将结合转换为字符串对象，然后保存。读入时，将字符串对象转为整数集合对象

ziplist编码的对象（包括列表，哈希，有序集合）

• type为REDIS_RDB_TYPE_LIST_ZIPLIST, REDIS_RDB_TYPE_HASH_ZIPLIST, REDIS_RDB_TYPE_ZSET_ZIPLIST
• 先将压缩列表转换为字符串对象，保存到rdb文件
• 读取时根据type类型，读入字符串，转换为压缩列表对象

分析RDB文件

使用linux自带的od命令

使用linux自带的od命令可以查看rdb文件信息，比如od -c dump.rdb,以Ascii打印，下图显示docker创建的redis中，空的rdb文件输出的内容

工具

• rdb转json的工具
• 图形界面rdbtool
• rdr内存分析工具

AOF持久化

AOF写入与同步

除了RDB持久化外，redis还提供了AOF持久化功能。区别如下：

• RDB通过保存数据库中键值对记录数据库状态
• AOF通过保存服务器执行的写命令来记录数据库状态

AOF持久化分为三步：

• 命令追加：命令append到redisServer全局变量的aof_buf成员中
• 文件写入：
• 文件同步

事件结束时调用flushAppendOnlyFile函数，考虑是否将aof_buf内容写到AOF文件里（参数决定）

• always：所有内容写入并同步到AOF文件（写入的是缓冲区，同步时从缓冲区刷到磁盘）
• everysec：默认值。写入AOF文件，如果上次同步时间距现在草稿1s，同步AOF。
• no：只写入AOF文件，由系统决定何时同步

AOF载入与还原

服务器只需要读入并执行一遍AOF命令即可还原数据库状态，读取的步骤如下：

• 创建一个不带网络连接的伪客户端：因为命令只能在客户端执行
• 从AOF读取一条写命令
• 使用客户端执行该命令
• 重复上面的步骤，直到完成

AOF重写

• 随着时间流逝，AOF文件内容会越来越大，影响redis性能。redis提供重写功能解决该问题。
• 重写是通过读取redis当前数据状态完成的，而不是解析AOF文件
• 为了不影响redis正常响应，重写功能通过创建子进程（注意不是线程）完成
• 为了解决父子进程数据不一致问题（父进程接收新的请求），redis设置了AOF重写缓冲区。新的命令在AOF缓冲区和AOF重写缓冲区中双写。

事件

redis是一个事件驱动程序，事件包括两大类：

• 文件事件：socket通讯完成一系列操作
• 时间事件：某些需要在给定时间执行的操作

文件事件

• redis基于Reactor模式开发事件处理器，使用IO多路复用监听套接字。关于IO多路复用可参考之前的文章五种io模型对比
• ，虽然事件处理器以单线程运行，通过io多路复用，能同时监听多个套接字实现高性能

事件处理器的构成

• 文件事件：套接字操作的抽象
• io多路复用程序：同时监听多个套接字，并向事件分派器传送事件。多个套接字按队列排序
• 文件事件分派器：接收套接字，根据事件类型调用相应的事件处理器
• 事件处理器：不同的函数实现不同的事件

IO多路复用的实现

可选的io多路复用包括select,epoll,evport,kqueue实现。每种实现都放在单独的文件中。编译时根据不同的宏切换不同的实现

事件类型

#define AE_NONE 0       /* No events registered. */
#define AE_READABLE 1   /* Fire when descriptor is readable. */
#define AE_WRITABLE 2   /* Fire when descriptor is writable. */

处理器

redis为文件事件编写了多个处理器，分别用于实现不同的网络需求，在networking.c文件中，包括：

• 连接应答处理器：监听套接字，接收客户端命令请求。对应函数为acceptTcpHandler。内部调用socket编程的accpt函数
• 命令请求处理器：负责读入套接字中的命令请求内容。对应函数为readQueryFromClient。内部调用socket编程的read函数
• 命令回复处理器：负责将回复通过套接字返回给客户。对应函数为sendReplyToClient。内部调用socket班车的write函数

时间事件

分类

时间事件分类以下两大类，取决于时间处理器的返回值：

• 定时事件：返回AE_NOMORE（-1）
• 周期性事件：非AE_NOMORE值。单机版只有serverCron一个周期性事件

属性

时间事件包括三个属性：

• id：服务器创建的全局唯一标识
• when：事件到达时间
• timeProc：处理器，一个函数

实现

• 所有时间事件放在一个无序链表中

  

• 执行时需要遍历链表
• ae.c/aeCreateTimeEvent：创建时间处理器
• aeSearchNearestTimer：返回距离当前时间最近的时间事件
• ae.c/processTimeEvents：遍历时间处理器并执行

事件调度

• 事件调度和执行由ae.c/aeProcessEvents函数负责
• 该函数被放在ae.c/aeMain函数中的一段循环里面，不断执行直到服务器关闭
• aeMain被server.c的main函数调用

int main() {
    ...
    aeMain(server.el);
    ...
}
void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
    while (!eventLoop->stop) {
        if (eventLoop->beforesleep != NULL)
            eventLoop->beforesleep(eventLoop);
        aeProcessEvents(eventLoop, AE_ALL_EVENTS|AE_CALL_AFTER_SLEEP);
    }
}

客户端

redis服务器为每个连接的客户端建立了一个redisClient的结构，保存客户端状态信息。所有客户端的信息放在一个链表里。可通过client list命令查看

struct redisServer {
    ...
    list *clients;
    ...
}

客户端数据结构如下：

typedef struct client {
    uint64_t id;            /* Client incremental unique ID. */
    //客户端套接字描述符，伪客户端该值为-1（包括AOF还原和执行Lua脚本的命令）
    int fd;                 /* Client socket. */
    redisDb *db;            /* Pointer to currently SELECTed DB. */
    // 客户端名字，默认为空，可通过client setname设置
    robj *name;             /* As set by CLIENT SETNAME. */
    // 输入缓冲区，保存客户端发送的命令请求，不能超过1G
    sds querybuf;           /* Buffer we use to accumulate client queries. */
    size_t qb_pos;          /* The position we have read in querybuf. */
    sds pending_querybuf;   /* If this client is flagged as master, this buffer
                               represents the yet not applied portion of the
                               replication stream that we are receiving from
                               the master. */
    size_t querybuf_peak;   /* Recent (100ms or more) peak of querybuf size. */
    // 解析querybuf，得到参数个数
    int argc;               /* Num of arguments of current command. */
    // 解析querybuf，得到参数值
    robj **argv;            /* Arguments of current command. */
    // 根据前面的argv[0]， 找到这个命令对应的处理函数
    struct redisCommand *cmd, *lastcmd;  /* Last command executed. */
    int reqtype;            /* Request protocol type: PROTO_REQ_* */
    int multibulklen;       /* Number of multi bulk arguments left to read. */
    long bulklen;           /* Length of bulk argument in multi bulk request. */
    // 服务器返回给客户端的可被空间，固定buff用完时才会使用
    list *reply;            /* List of reply objects to send to the client. */
    unsigned long long reply_bytes; /* Tot bytes of objects in reply list. */
    size_t sentlen;         /* Amount of bytes already sent in the current
                               buffer or object being sent. */
    // 客户端的创建时间
    time_t ctime;           /* Client creation time. */
    // 客户端与服务器最后一次互动的时间
    time_t lastinteraction; /* Time of the last interaction, used for timeout */
    // 客户端空转时间
    time_t obuf_soft_limit_reached_time;
    // 客户端角色和状态：REDIS_MASTER, REDIS_SLAVE, REDIS_LUA_CLIENT等
    int flags;              /* Client flags: CLIENT_* macros. */
    // 客户端是否通过身份验证的标识
    int authenticated;      /* When requirepass is non-NULL. */
    int replstate;          /* Replication state if this is a slave. */
    int repl_put_online_on_ack; /* Install slave write handler on ACK. */
    int repldbfd;           /* Replication DB file descriptor. */
    off_t repldboff;        /* Replication DB file offset. */
    off_t repldbsize;       /* Replication DB file size. */
    sds replpreamble;       /* Replication DB preamble. */
    long long read_reploff; /* Read replication offset if this is a master. */
    long long reploff;      /* Applied replication offset if this is a master. */
    long long repl_ack_off; /* Replication ack offset, if this is a slave. */
    long long repl_ack_time;/* Replication ack time, if this is a slave. */
    long long psync_initial_offset; /* FULLRESYNC reply offset other slaves
                                       copying this slave output buffer
                                       should use. */
    char replid[CONFIG_RUN_ID_SIZE+1]; /* Master replication ID (if master). */
    int slave_listening_port; /* As configured with: SLAVECONF listening-port */
    char slave_ip[NET_IP_STR_LEN]; /* Optionally given by REPLCONF ip-address */
    int slave_capa;         /* Slave capabilities: SLAVE_CAPA_* bitwise OR. */
    multiState mstate;      /* MULTI/EXEC state */
    int btype;              /* Type of blocking op if CLIENT_BLOCKED. */
    blockingState bpop;     /* blocking state */
    long long woff;         /* Last write global replication offset. */
    list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
    dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
    list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */
    sds peerid;             /* Cached peer ID. */
    listNode *client_list_node; /* list node in client list */

    /* Response buffer */
    // 记录buf数组目前使用的字节数
    int bufpos;
    // (16*1024)=16k,服务器返回给客户端的内容缓冲区。固定大小，存储一下固定返回值（如‘ok’）
    char buf[PROTO_REPLY_CHUNK_BYTES];
} client;

服务器

服务器记录了redis服务器所有的信息，包括前面介绍的一些，罗列主要的如下：

struct redisServer {
    ...
    // 所有数据信息
    redisDb *db;
    // 所有客户端信息
    list *clients;
    
     /* time cache */
    // 系统当前unix时间戳,秒
    time_t unixtime;    /* Unix time sampled every cron cycle. */
    time_t timezone;    /* Cached timezone. As set by tzset(). */
    int daylight_active;    /* Currently in daylight saving time. */
    // 系统当前unix时间戳,毫秒
    long long mstime;   /* Like 'unixtime' but with milliseconds resolution. */
    
    // 默认没10s更新一次的时钟缓存，用于计算键idle时长
    unsigned int lruclock;      /* Clock for LRU eviction */
    
    // 抽样相关的参数
    struct {
        // 上次抽样时间
        long long last_sample_time; /* Timestamp of last sample in ms */
        // 上次抽样时，服务器已经执行的命令数
        long long last_sample_count;/* Count in last sample */
        // 抽样结果
        long long samples[STATS_METRIC_SAMPLES];
        int idx;
    } inst_metric[STATS_METRIC_COUNT];
    
    // 内存峰值
    size_t stat_peak_memory;        /* Max used memory record */
    // 关闭服务器的标识
    int shutdown_asap;          /* SHUTDOWN needed ASAP */
    // bgsave命令子进程的id
    pid_t rdb_child_pid;            /* PID of RDB saving child */
    // bgrewriteaof子进程id
    pid_t aof_child_pid;            /* PID if rewriting process */
    // serverCron执行次数
    int cronloops;              /* Number of times the cron function run */
    ...
}

参考

• 《redis设计与实现》
• rdbtool wiki
• rdr分析工具