十四：Redis持久化之rdb

最新推荐文章于 2022-10-10 14:27:32 发布
最新推荐文章于 2022-10-10 14:27:32 发布
阅读量440 收藏
点赞数
分类专栏： 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013565163/article/details/106860620
版权

十四：Redis持久化之rdb

Redis提供了两种持久化的方式:AOF与RDB: RDB偏重在保存某个时间redis的快照；AOF
偏重在实时保存的效率上。两者方案侧重点不同。

RDB

RDB:redis database 意思时在指定时间间隔内将内存中的数据写入到磁盘也就是说一段时间对redis进行一次快照;rdb写入的是二进制数据所以文件
大小也更紧凑些。

RDB: 一般应用在对数据冷备、复制传输，重启redis加载rdb的数据也更快一些。

配置项

可以在redis.conf中配置是否开启RDB（默认已开启）、多久保存一下快照以及快照文件名、存储快照地址。如果不想使用快照，你可以注释掉
下面的快照。

下面是在redis.cong配置rdb的配置项。


################################ SNAPSHOTTING  ################################

# 表示多久保存一次 save  <seconds> <changes>  表示在多少秒内直到有多少key改变才触发rdb持久化
#900秒（15分钟）内至少一个key改变触发持久化
save 900 1
#300秒(5分钟)内至少10个Key改变触发持久化
save 300 10
#60秒(1分钟)内至少10000个key改变触发出持久化
save 60 10000

# 当设置为yes表示：当进行快照的时候出现了失败，redis将拒绝接收后面客户端的写入命令操作
# 当设置为no表示：当进行快照的时候出现了失败，redis将接收接收后面客户端的写入命令操作
stop-writes-on-bgsave-error yes


# 是否开启快照文件压缩（使用LZF算法）
# 默认为yes,会压缩rdb的内容，节省空间
# 当设置为no,表示不开启压缩节省cpu，实际上不建议这中做法，因为rdb使用场景是冷备、复制传输，
# 希望文件大小越小越好
rdbcompression yes

# 是否对rdb文件使用CRC64算法进行检查，如果开启在保存和加载rdb文件市需要消耗10%性能，
# 如果禁用则不进行校验
rdbchecksum yes

#  配置rdb保存的文件名
dbfilename "dump.rdb"


# rbm保存在磁盘的目录(仅仅是目录，这里不要带文件名),aof的保存路径也共用这个目录
dir "/homepa1/redis"

运行流程

这里只说明一下bgsave的流程（save的流程是同步的）

bgsave运行流程

流程解释

  1. 客户端执行bgsave命令，服务端接收到命令
  2. 父进程判断当前是否有正在执行的子进程，如果有则直接返回Background save already in progress,否则fork一个子进程出来
  3. fork（fork这段时间不响应）出了子进程，父进程继续响应客户端的请求
  4. 子进程保存当前所有key以及其value到rdb文件
  5. 子进程保存完毕，信号量通知父进程

我们可以看到bgsave这里处理fork子进程的时候会阻塞，其他都是可以响应客户端请求的；
如果是save，会在接收到save命令后不fork子进程，而是阻塞式的写入rdb,此时是不能响应客户端的请求，
对于键多并且value非常大的情况下对redis灾难性。会导致整个缓存层对外停止服务。

相关命令

save

/**
**  redis.c
**/

struct redisCommand readonlyCommandTable[] = {
  {"save",saveCommand,1,0,NULL,0,0,0}

}


1. 如果有子进程正在处理，则直接返回
2. 同步保存rdb，如果成功返回 ok
3. 保存失败返回err

/**
** db.c
**/

void saveCommand(redisClient *c) {
    //1.如果有子进程正在处理，则直接返回
    if (server.bgsavechildpid != -1) {
        addReplyError(c,"Background save already in progress");
        return;
    }
    //2. 同步保存rdb，如果成功返回 ok
    if (rdbSave(server.dbfilename) == REDIS_OK) {
        addReply(c,shared.ok);
    } else {
    //3. 保存失败返回err
        addReply(c,shared.err);
    }
}


1. 构造临时保存rdb文件名
2. 打开文件，准备写操作
3. 打开失败，直接返回错误信息 
4. 写入rdb文件开始字符失败，跳转到关闭文件，以及输出错误
5. 循环保存redis每个数据库中的键值对
6. 如果当前循环数据库键个数为0，则继续下一个数据库
7. 构建当前循环数据库键多迭代器
8. 如果没有生成迭代器，则关闭文件，返回错误
9. 写入当前保存键值对的数据库
10. 迭代保存单个键值对 
11. 如果过期时间保存过期时间
12. 保存键值对
13. 写入rdb文件结尾标识符         
14. 刷新文件，同步写入，关闭文件
15. 使用redis配置文件配置的rdb文件名重命名上面的写入的临时文件 
16. 保存成功，输出日志
17. 上面的发生错误跳转到这里，关闭文件释放临时文件，输出日志,关闭迭代器


/**
** rdb.c
**
**/

/* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */
int rdbSave(char *filename) {
    dictIterator *di = NULL;
    dictEntry *de;
    FILE *fp;
    char tmpfile[256];
    int j;
    time_t now = time(NULL);

    
    if (server.vm_enabled)
        waitEmptyIOJobsQueue();
    // 1. 构造临时保存rdb文件名
    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
    // 2. 打开文件，准备写操作
    fp = fopen(tmpfile,"w");
    //3. 打开失败，直接返回错误信息 
    if (!fp) {
        redisLog(REDIS_WARNING, "Failed saving the DB: %s", strerror(errno));
        return REDIS_ERR;
    }
    // 4. 写入rdb文件开始字符失败，跳转到关闭文件，以及输出错误
    if (fwrite("REDIS0001",9,1,fp) == 0) goto werr;
    // 5. 循环保存redis每个数据库中的键值对
    for (j = 0; j < server.dbnum; j++) {
        redisDb *db = server.db+j;
        dict *d = db->dict;
        //6. 如果当前循环数据库键个数为0，则继续下一个数据库
        if (dictSize(d) == 0) continue;
        //7. 构建当前循环数据库键多迭代器
        di = dictGetSafeIterator(d);
        //8. 如果没有生成迭代器，则关闭文件，返回错误
        if (!di) {
            fclose(fp);
            return REDIS_ERR;
        }

        //9. 写入当前保存键值对的数据库
        if (rdbSaveType(fp,REDIS_SELECTDB) == -1) goto werr;
        if (rdbSaveLen(fp,j) == -1) goto werr;

        //10. 迭代保存单个键值对 
        while((de = dictNext(di)) != NULL) {
            sds keystr = dictGetEntryKey(de);
            robj key, *o = dictGetEntryVal(de);
            time_t expiretime;
            
            initStaticStringObject(key,keystr);
            expiretime = getExpire(db,&key);

            //11. 如果过期时间保存过期时间
            if (expiretime != -1) {
                /* If this key is already expired skip it */
                if (expiretime < now) continue;
                if (rdbSaveType(fp,REDIS_EXPIRETIME) == -1) goto werr;
                if (rdbSaveTime(fp,expiretime) == -1) goto werr;
            }
           //12. 保存键值对
            if (!server.vm_enabled || o->storage == REDIS_VM_MEMORY ||
                                      o->storage == REDIS_VM_SWAPPING) {
                /* Save type, key, value */
                if (rdbSaveType(fp,o->type) == -1) goto werr;
                if (rdbSaveStringObject(fp,&key) == -1) goto werr;
                if (rdbSaveObject(fp,o) == -1) goto werr;
            } else {
                /* REDIS_VM_SWAPPED or REDIS_VM_LOADING */
                robj *po;
                /* Get a preview of the object in memory */
                po = vmPreviewObject(o);
                /* Save type, key, value */
                if (rdbSaveType(fp,po->type) == -1) goto werr;
                if (rdbSaveStringObject(fp,&key) == -1) goto werr;
                if (rdbSaveObject(fp,po) == -1) goto werr;
                /* Remove the loaded object from memory */
                decrRefCount(po);
            }
        }
        dictReleaseIterator(di);
    }
    //13. 写入rdb文件结尾标识符
    if (rdbSaveType(fp,REDIS_EOF) == -1) goto werr;

   //14. 刷新文件，同步写入，关闭文件
    fflush(fp);
    fsync(fileno(fp));
    fclose(fp);

    //15. 使用redis配置文件配置的rdb文件名重命名上面的写入的临时文件 
    if (rename(tmpfile,filename) == -1) {
        redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
        unlink(tmpfile);
        return REDIS_ERR;
    }
    //16. 保存成功，输出日志
    redisLog(REDIS_NOTICE,"DB saved on disk");
    server.dirty = 0;
    server.lastsave = time(NULL);
    return REDIS_OK;
    //17. 上面的发生错误跳转到这里，关闭文件释放临时文件，输出日志,关闭迭代器
werr:
    fclose(fp);
    unlink(tmpfile);
    redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
    if (di) dictReleaseIterator(di);
    return REDIS_ERR;
}


/**
** 上面的方法保存时最终会调用下面这个方法
**  这个方法也时调用fwrite这个C的标准库函数
**/
static int rdbWriteRaw(FILE *fp, void *p, size_t len) {
    if (fp != NULL && fwrite(p,len,1,fp) == 0) return -1;
    return len;
}

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)

- prt  指针指向要写入的元素
- size 写入元素的大小
- nmemb 写入的元素个数
- stream 打开的文件流

返回值：成功写入的元素个数，如果不等于nmemb则返回错误
bgsave

关于fork函数需要理解，每当调用一次fork函数时，会返回两个两次。
一次是在调用进程中（父进程）返回一次，返回值是新派生的进程的进程ID。
一次是在子进程中返回，返回值是0，代表当前进程为子进程。
如果返回-1，那么则代表在创建子进程的过程中出现了错误。


/**
**  redis.c
**/

struct redisCommand readonlyCommandTable[] = {
   {"bgsave",bgsaveCommand,1,0,NULL,0,0,0},
}

1. 如果有子进程在处理则返回
2. fork子进程来处理rdb
3. 失败返回错误

/**
** db.c
**/
void bgsaveCommand(redisClient *c) {
    //1. 如果有子进程在处理则返回
    if (server.bgsavechildpid != -1) {
        addReplyError(c,"Background save already in progress");
        return;
    }
    //2. fork子进程来处理rdb
    if (rdbSaveBackground(server.dbfilename) == REDIS_OK) {
        addReplyStatus(c,"Background saving started");
    } else {
    //3. 失败返回错误
        addReply(c,shared.err);
    }
}



1. 如果有子进程在处理则返回
2. fork出子进程，父子进程执行各自的逻辑 fork = 0：表示现在时子进程，fork > 0表示父进程， fork = -1表示fork失败
3.调用save命令保存rdb的函数，不过与这里相比,bgsave是在子进程中执行，save是在父进程中执行
4. 父进程中执行下面逻辑，如果子进程等于-1，表示子进程创建失败,输出失败日志，返回错误
5. 成功，子进程在执行rdb生成快照，此时主进程可以继续处理响应

/**
**fork子进程来生成快照
** rdb.c
**/

int rdbSaveBackground(char *filename) {
    pid_t childpid;
     //1. 如果有子进程在处理则返回
    if (server.bgsavechildpid != -1) return REDIS_ERR;
    if (server.vm_enabled) waitEmptyIOJobsQueue();
    server.dirty_before_bgsave = server.dirty;
    //2. fork出子进程，父子进程执行各自的逻辑 fork = 0：表示现在时子进程，fork > 0表示父进程， fork = -1表示fork失败
    if ((childpid = fork()) == 0) {
        /* Child */
        if (server.vm_enabled) vmReopenSwapFile();
        if (server.ipfd > 0) close(server.ipfd);
        if (server.sofd > 0) close(server.sofd);
        //3.调用save命令保存rdb的函数，不过与这里相比,bgsave是在子进程中执行，save是在父进程中执行
        if (rdbSave(filename) == REDIS_OK) {
            _exit(0);
        } else {
            _exit(1);
        }
    } else {
        /* Parent */
        //4. 父进程中执行下面逻辑，如果子进程等于-1，表示子进程创建失败,输出失败日志，返回错误
        if (childpid == -1) {
            redisLog(REDIS_WARNING,"Can't save in background: fork: %s",
                strerror(errno));
            return REDIS_ERR;
        }
        //5. 成功，子进程在执行rdb生成快照，此时主进程可以继续处理响应
        redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
        server.bgsavechildpid = childpid;
        updateDictResizePolicy();
        return REDIS_OK;
    }
    return REDIS_OK; /* unreached */
}

copy-on-write写时复制技术

在上面我们fork进程的时候，有没有想过一个问题呢,如果父进程的键值对很大， 占用的内存很多，rdb的时候，fork一个进程岂不是需要两倍的内存，
以及更多时间呢？

事实上，fork的时候时不需要两倍内存的，因为这里使用了linux的cow技术

写时复制技术（cow）: fork创建出来的子进程，与父进程共享物理内存空间，父子进程通过不同的页表指向想用的物理地址。

虽然fork创建的子进程不需要拷贝父进程的物理内存空间，但是会复制父进程的空间内存页
表。例如对于10GB的Redis进程，需要复制大约20MB的内存页表，因此fork
操作耗时跟进程总内存量息息相关(引自：《redis开发与运维》作者：付磊 张益军)

父子进程，内存页

fork函数，每当调用一次fork函数时，会返回两次值，一次是在调用进程中(父进程)返回一次，
返回值时新生成的进程也即子进程id;一次是在子进程中返回，返回值是0，代表当前进程为子进程；
如果返回-1，则表示创建子进程失败。（两次返回可以看到上面rdbSaveBackground方法）

参考

Linux进程概念

C library function - fwrite()

写时复制(Copy On Write)

《Redis开发与运维》作者：付磊、张益军

我爱看明朝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis 持久化之RDB和AOF.doc
10-09
Redis 有两种持久化方案，RDB （Redis DataBase）和 AOF （Append Only File）。如果你想快速了解和使用RDB和AOF，可以直接跳到文章底部看总结。本章节通过配置文件，触发快照的方式，恢复数据的操作，命令操作演示，优缺点来学习 Redis 的重点知识持久化。
Redis持久化一一RDB
01-07
Redis可以实现数据的持久化存储，即将数据保存到磁盘上。 Redis的持久化存储提供两种方式：RDB与AOF。RDB是默认配置。默认是关闭AOF模式的，AOF需要手动开启 RDB（Redis DataBase）:在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里 Redis会单独创建(fork)一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整
持久化之RDB
qq_36517313的博客
05-26 1261
1. 是什么 在指定的时间间隔内将内存中的数据集快照写入磁盘， 也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里 Redis默认是开启的 2. 工作原理 Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB
Redis持久化RDB（重点）
JinXYan的博客
03-21 164
1. 什么是redis的持久化？ Redis 是一款内存数据库，也就是说它把数据都存储在内存中，持久化就是把内存中的数据存储到电脑的磁盘上。 Redis 提供了不同级别的持久化方式： RDB 持久化方式能够在指定的时间间隔能对你的数据进行快照存储。 AOF 持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据。 本篇介绍第一种：R...
Redis(设计与实现):23---RDB持久化之自动间隔性保存（save选项、struct saveparam、dirty属性、lastsave属性）
董哥的黑板报
11-28 888
一、自动间隔性保存介绍（save选项） 前面一篇文章介绍了SAVE、BGSAVE命令，其中BGSAVE命令可以在不阻塞服务器进程的情况下执行，所以Redis允许用户通过设置服务器配置的save选项，让服务器每隔一段时间自动执行一次BGSAVE命令 save选项的格式 用户可以通过save选项设置多个保存条件，但只要其中任意一个条件被满足，服务器就会执行BGSAVE命令 如果用户没有主动设置...
【redis 四】一文搞懂redis持久化之RDB
李光 未来科技
06-10 1897
前言： redis持久化分为RDB和AOF，此篇博文着重讲解RDB方式的持久化。演示系统 centos7。 1、官网说明 地址：https://redis.io/topics/persistence 以下内容为有道词典翻译 Redis持久性 RDB持久性按指定的时间间隔执行数据集的时间点快照。 RDB的优势 RDB是Redis数据的非常紧凑的单文件时间点表示。RDB文件非常适合备份。例如，您可能希望在最近的24小时内每小时存档一次RDB文件，并在30天之内每天保存一次RDB快照。这使您可以在灾难情况下轻松还
RedisRDB持久化机制
Leon_Jinhai_Sun的博客
11-13 235
什么是Redis持久化 什么是Redis持久化,就是将内存数据保存到硬盘。 Redis 持久化存储 (AOF 与 RDB 两种模式) RDB持久化 RDB 是以二进制文件，是在某个时间 点将数据写入一个临时文件，持久化结束后，用这个临时文件替换上次持久化的文件，达到数据恢复。 优点：使用单独子进程来进行持久化，主进程不会进行任何 IO 操作，保证了 redis 的高性能 缺点：RDB 是间...
Redis持久化之RDB（详解）
酷小亚
10-10 2266
Redis持久化之RDB（详解） 一、初识RDB 二、RDB特点 1、优势 2、劣势 三、RDB操作 1、概述 2、操作 四、总结
Redis持久化之RDB
不完美的红烧肉的博客
02-18 4523
Redis提供了2个不同形式的持久化策略： RDB (redis database) AOF (append of file) 这篇文章则记录一下我学习RDB过程中的一些笔记，分享给大家。 RDB 模式 rdb是redis默认的持久化策略，在RDB模式下，可以将redis在内存中的数据库状态保存到磁盘里面（以内存快照的形式），避免数据意外丢失。 RDB持久化功能既可以手动执行，也可以通过配置文件定期执行。 RDB通过生成一个经过压缩的二进制文件，保存数据库状态，可以通过该文件进行还原。
Redis的RDB机制
月亮的博客
07-27 1万+
一、什么是RDB机制 RDB 是 Redis DataBase 的缩写，即内存块照。因为Redis的数据时存在内存中的，当服务器宕机时，Redis中存储的数据就会丢失。这个时候就需要内存快照来恢复Redis中的数据了。快照就是在某一时刻，将Redis中的所有数据，以文件的形式存储起来。这就类似于照片，当你给朋友拍照时，一张照片就能把朋友一瞬间的形象完全记下来。 二、RDB机制是如何实现的 1、全量快照 Redis 的数据都在内存中，为了提供所有数据的可靠性保证，它执行的是......
Redis持久化RDB和AOF区别详解
12-14
RDB是Redis内存到硬盘的快照，用于redis持久化，创建RDB二进制文件，将存储在内存中的数据，持久化的放到硬盘中，当我们需要这些数据的时候，启动载入RDB文件，数据将会被存入内存中，其实RDB就是一种快照的方式持久...
Redis持久化 - RDB和AOF
08-17
Redis持久化 - RDB和AOF
第四十六章：Redis数据库持久化1
08-08
二、持久化的作用以及实现方式 三、RDB持久化方式配置 四、AOF持久化方式配置 一、数据库概述：Redis是一种高级key-value数据库 二、持久化的作用
JDBC- 正确关闭数据库连接
热门推荐
勿在浮沙筑高台
07-24 5万+
在我们刚开始学习 JDBC时，由于没有使用数据库连接池，我们代码中的每一次连接都需要我们自己来关闭。 不过很多人，都没有正确关闭，包括一些 JDBC的教程。 例如： https://www.javatpoint.com/example-to-connect-to-the-oracle-database 没有正确关闭：import java.sql.*; class Or
微信支付服务商接入指引
勿在浮沙筑高台
12-28 3万+
微信支付服务商接入指引本文主要针对服务商下特约商户的小程序支付进行讲解。（扫码支付， h5支付大致流程都差不多，了解了小程序支付能够很快接入其他支付类型）说明：本文中的支付都是指在服务商模式下支付主体 服务商:拥有支付开发能力的第三方提供商 普通商户: 拥有开发能力的商户 特约商户:服务商下的商户一个商家主体可以在不同服务商下申请特约商户，每个服务商都会给商家主体在此服务商下一个特约商户号。普通商户
使用 ssm 框架，基本流程
勿在浮沙筑高台
07-11 2万+
题目，写的有点大了，其实就是 对一张表的基本处理，增删改查的基本操作演示。 好了，我们开始了。假如，我们在做一个单表处理，就举例是 学院（某个大学的学院） 吧。 首先，我们分析 学校这样表有哪些属性，分析完后，就可以在数据库中 建 depart 这张表了。 有三个属性：然后要在项目中 做一个 depart Bean 可以使用generate mybais 工具自动生成 depart mo
SpringBoot+websocket+定时任务
勿在浮沙筑高台
06-12 2万+
SpringBoot+websocket+定时任务 SpringBoot+websocket 概念 websocket:由于http协议时基于 请求-响应模型 服务端的每次响应都必须有客户端发起（浏览器）的请求。如果服务端想主动推送消息到客户端是很难满足的。 如果一定想使用http来做服务端主动推动，只能客户端不停的发起轮询请求，如果访问量很很大，这种模式会拖垮服务器。造成...
Parameter ‘book‘ not found. Available parameters are [0, 1, param1, param2]
勿在浮沙筑高台
06-25 2万+
在用mybatis 时，出现以下错误：Parameter 'book' not found. Available parameters are [0, 1, param1, param2] 原因是 在mapper 映射的函数参数没有加 @param(“book”)错误的： List<Book> selectBySchool(Page<Book> page, BookExample exampl
使用 apache poi 读取excel 把 数字转换成 字符
勿在浮沙筑高台
01-18 2万+
最近在做一个 导入用户的功能。用户有一个电话属性 和密码 。 在导入的时候 变成如果密码填写：123 poi 读取会变成 123.0 电话 会变成科学计数。 实在是头疼啊。 然后各种中文网百度，没有找到靠谱的答案。 使用了神器网站：stackover ，找到了，解决办法： cell.setCellType(Cell.CELL_TYPE_STRING); 使用这条语句就
redis持久化机制RDB
最新发布
09-06
Redis的持久化机制主要有两种，一种是RDB（Redis DataBase），另一种是AOF（Append Only File）。 RDB是Redis默认的持久化方式。它通过将内存中的数据以快照的形式写入到磁盘中的二进制文件中来实现持久化。RDB持久...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值