redis内存篇

已于 2022-04-24 22:07:21 修改
阅读量758 收藏
点赞数
分类专栏： redis 文章标签： redis
于 2022-04-24 22:06:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alexia23/article/details/124393125
版权

Redis归属

随着计算硬件的价格越来越便宜，人们对性能的要求越来越高，很多用户会根据自己的业务场景选择读写速度很快的内存数据库，呀比如大名鼎鼎的redis数据库，其属于kv型的NOSQL数据库。

这里小编可以简单介绍下数据库。数据库可以简单分为关系型数据库和非关系型数据库。

关系型数据库最典型的数据结构是表，由二维表及其之间的联系所组成的一个数据组织，常见的Oracle、Mysql、PostgreSQL、MariaDB、SQLite、SQL Server等，读写速度依赖于磁盘I/O。

非关系型数据库严格上不是一种数据库，应该是一种数据结构化存储方法的集合，可以是文档或者键值对等。一般可以再细分为：

  1. 文档型
    1. 举例：mongoDB、CouchDB
    2. 数据：key-value的键值对，value一般为结构化的数据（类似json），存储的内容是文档型的，有机会对某些字段进行索引
  2. key-vaue型
    1. 举例：redis、MemcacheDB
    2. 数据：通过hashtable实现的key-value的键值对，value的格式多样
    3. 补充：一般用于内容缓存，读写速度快
  3. 列式数据库
    1. 举例：HBase、Cassandra、Hypertable
    2. 数据：分布式的文件系统，以列簇式存储，将同一列的数据存在一起，方便做数据压缩
  4. 图型数据库
    1. 举例：Neo4J、FlockDB
    2. 数据：图结构，多用于构建知识图谱及最短路径寻址等，比较难做分布式集群方案

Redis分类

redis，可以简单分为主从版本和cluster集群版本。

单机版本：

  1. 一主多从：可以通过sentinel实现故障转移，或者其他的监控程序当发现主不可用，将从提升为主

  2. 可以支持读写分离：主负责写，将数据复制到从节点，从节点负责读

cluster集群版本：

  1. 采用的去中心化的设计思想，节点之间是fullmesh的连接，每个节点上保存了各自的数据和整个集群的状态。

Redis容量

生产上redis数据库可以容纳多少数据，小编去亚马逊的官网瞅了一眼。最大可以扩展到一个内存数据高达 310 TiB 的集群，或使用具有数据分层的集群时为 982 TiB。（参考以下链接）

https://aws.amazon.com/cn/elasticache/redis/

Redis核心问题

云上的redis数据库一般运行在容器中，会有适当的资源配额。在某些场景下，会出现内存满了，容器发生了OOM（out of memory）导致重启，如果该场景redis没有开启持久化配置，就会导致数据丢失。（那可太心痛了）

因此，了解redis容器的内存消耗非常必要～对于一个redis节点，上面运行的redis进程有哪些用到内存的地方呢

  1. redis进程本身消耗的内存

    1. 当一个没有数据的redis节点，它的used_memory_rss(操作系统角度显示redis进程占用的物理内存总量)即表示进程本身消耗的内存，一般也就几MB左右，可以忽略不计

  2. redis数据存储消耗的内存

    1. 相关的数据结构
    2. 实际存储的数据
    3. rehash的占用：当key的数据比较多的场景下，渐进实施rehash的过程中，会存储很多中间数据在内存中

  3. redis缓存区的内存

    1. 客户端缓冲区

      1. 输入缓冲区
        1. client-query-buffer-limit用来控制客户端传递给redis的数据大小，默认为1G【注意：在使用Redis时应尽量避免超大Key】
        2. 如果有很多的multi/exec命令请求，也可以根据自己的需求提高这个设置项
      2. 输出缓冲区（client-output-buffer-limit用来控制输出缓冲区大小）
        1. 普通客户端（包含monitor clients）
          1. 用monitor监听redis的请求命令时，如果redis的qps比较高，对应的monitor无法快速接收这些数据，就会在客户端缓冲区形成积压，消耗redis内存
          2. redis7.0 rc1只支持限制单个普通客户端输入输出缓冲区的上限；听说redis7.0 rc1版本支持限制全部客户端的总内存，用这个config：maxmemory-client（后续详解）
        2. 从客户端
          1. 主节点会为每一个从节点单独建立一条连接用于命令复制
        3. 订阅客户端
          1. 可以配置输出缓冲区的大小
          2. 当订阅服务的消息生产大于消费速度，输出缓冲区就会积压，最后可能导致溢出
      client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>

当客户端的输出缓冲区的大小=hard limit则断开连接；当输出缓冲区的大小=soft limit持续soft seconds也断开连接

普通客户端 client-output-buffer-limit normal 0 0 0 无限制
slave客户端 client-output-buffer-limit slave 内存的1/20mb 内存的1/40mb 60
pub/sub客户端 client-output-buffer-limit pubsub 128mb 64mb 60

    2. 复制积压缓冲区

      1. 主从节点之间会进行数据同步，通过psync可以实现全量和部分复制。psync [runId] [offset]

        1. runid: 每个redis节点重启之后都会生成唯一的runid。节点重启之后，runid会发生变化
        2. offset：主节点和从节点都各自维护主从复制偏移量。主节点有写入命令的时候，offset=offset+命令的字节长度。从节点收到主节点发送的命令后，也增加offset，并把自己的offset反馈发给主节点。主节点会保存主从的offset，从来判断主从的数据是否一致

      2. 主节点执行写操作，会把命令发送给从节点，同时还会写入复制积压缓冲区。所有的从节点共享同一份复制积压缓冲区

      3. 该缓冲区的大小可以根据实际情况设置。计算缓冲空间=主写入命令的速度x命令大小-网络传输命令速度x命令大小。用每秒的缓冲空间x2（扩大一倍）x允许主从断连的时间

      4. 线上环境一般设置为内存的1/20

      5. 官方解释

        1. 单位大小支持b、k、kb、m、mb、g、gb，单位不区分大小写，其中k、m、g间的计算倍数是1000，而kb、mb和gb的计算倍数是1024
        # Set the replication backlog size. The backlog is a buffer that accumulates
# replica data when replicas are disconnected for some time, so that when a replica
# wants to reconnect again, often a full resync is not needed, but a partial
# resync is enough, just passing the portion of data the replica missed while
# disconnected.
#
# The bigger the replication backlog, the longer the time the replica can be
# disconnected and later be able to perform a partial resynchronization.
#
# The backlog is only allocated once there is at least a replica connected.
#
# repl-backlog-size 1mb

    3. AOF缓冲区

      1. 增加：服务器执行完一个命令之后，会将命令以协议的格式追加到AOF缓冲区的末尾
      2. 清零：服务器每次结束一个事件循环之前，都会调用flushAppendOnlyFile函数判断是否要将缓冲区的数据持久化到AOF文件，如果持久化改AOF缓冲区则清空
      3. 频率：
        1. appendfsync：always（每个事件循环都要将缓冲区的内容写入主AOF文件【更新内存页缓存】，并同步AOF文件【持久化到磁盘】，出现故障，丢失一个事件循环的数据）
        2. appendfsync：everysec（每个事件循环都要将缓冲区的内容写入AOF文件，每隔1s在子线程对AOF进行一次同步操作）
        3. appendfsync：no（每个时间循环都将缓冲区的内容写入AOF文件，什么时间持久化到硬盘看操作系统的频率）
    # server.c/main
int main(int argc, char **argv) {
    // ... ... 下面列出几个关键调用，其他代码省略了
 
    //全局变量、配置的初始化
    initServerConfig();
 
    //运行时的初始化，包括EventLoop、db、初始化TimeEvent、FileEvent和Bio线程等
    initServer();
     
    //设置了两个回调函数，在相应的阶段来调用
    aeSetBeforeSleepProc(server.el,beforeSleep); 
    aeSetAfterSleepProc(server.el,afterSleep);
 
    //进入处理事件的无限循环，直到收到退出信号才会返回
    aeMain(server.el); 
 
    aeDeleteEventLoop(server.el);
    return 0;
}

# ae.c/aeMain
void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
 
    //收到退出信号时会将stop设置为true
    while (!eventLoop->stop) {
 
        //main函数中设置的，意思就是每次调用aeProcessEvents之前调用
        if (eventLoop->beforesleep != NULL)
            eventLoop->beforesleep(eventLoop);
 
        /*处理所有事件，并且需要调用 eventLoop->afterSleep
          执行顺序：
            - 处理网络IO事件
            - 处理时间事件
        */
        aeProcessEvents(eventLoop, AE_ALL_EVENTS|AE_CALL_AFTER_SLEEP);
    }
}

  4. redis内存碎片

    1. 概念：申请一块连续地址空间N字节时，剩余内存空间中没有大小为N字节的连续空间，这些剩余空间就是内存碎片

    2. 产生原因

      1. 内因：与内存分配器息息相关，内存分配器必须分配一块固定大小的连续内存空间。以jemalloc为例，是按照一系列固定的大小划分内存空间，例如8字节、16字节、32字节、…、2KB、4KB等。当程序申请的内存最接近某个固定值时，jemalloc就会给它分配相应大小的空间。
      2. 外因：
        1. 分配的空间比申请的空间大，会造成一部分的碎片
        2. 键值可能会被修改或者删除，会释放一部分空间

    3. info 查看内存碎片值

      1. mem_fragmentation_ratio，表示Redis当前的内存碎片率；
      2. used_memory_rss，表示操作系统实际分配给Redis的物理内存空间，里面包含了碎片；
      3. used_memory，表示Redis为了保存数据实际申请使用的空间

    4. 什么时候应该清理

      1. mem_fragmentation_ratio 大于 1.5 。这表明内存碎片率已经超过了50%

    5. 如何清理

      1. 暴力重启
      2. 自动清理（搬迁数据，将不连续的内存空间变成连续的），可能会阻塞redis（可以通过参数设置来控制影响）
      # The configuration parameters are able to fine tune the behavior of the
# defragmentation process. If you are not sure about what they mean it is
# a good idea to leave the defaults untouched.

# Enabled active defragmentation
# activedefrag yes

# Minimum amount of fragmentation waste to start active defrag
# 内存碎片超过100MB，开始清理
# active-defrag-ignore-bytes 100mb

# Minimum percentage of fragmentation to start active defrag
# 内存碎片空间占操作系统分配给redis的物理空间的比例达到10%，开始清理
# active-defrag-threshold-lower 10

# Maximum percentage of fragmentation at which we use maximum effort
# 内存碎片超过 100%，则尽最大努力整理
# active-defrag-threshold-upper 100

# Minimal effort for defrag in CPU percentage
# 清理使用的cpu最小为5%
# active-defrag-cycle-min 5

# Maximal effort for defrag in CPU percentage
# 清理使用的cpu超过75%，停止清理
# active-defrag-cycle-max 75

# Maximum number of set/hash/zset/list fields that will be processed from
# the main dictionary scan
# 将从主字典扫描中处理的最大 set/hash/zset/list 字段数
# active-defrag-max-scan-fields 1000

  5. fork子进程

    1. 主从同步的过程中，主节点做了哪些操作
      1. 主服务器执行 BGSAVE 命令， 生成一个 RDB 文件， 并使用缓冲区储存起在 BGSAVE 命令之后执行的所有写命令。
      2. 在 RDB 文件创建完毕之后，主服务器会通过socket，将 RDB 文件传送给从服务器。
      3. 从服务器在接收完主服务器传送过来的 RDB 文件之后，就会载入这个 RDB 文件，从而获得主服务器在执行 BGSAVE 命令时的所有数据。
      4. 当从服务器完成 RDB 文件载入操作， 并开始上线接受命令请求时，主服务器就会把之前储存在缓存区里面的所有写命令发送给从服务器执行。
    2. BGSAVE 跟 SAVE 的不同之处就在于，BGSAVE 会先 fork 一个子进程，由子进程来生成 RDB文件（而不是由父进程生成 RDB 文件，因为生成 RDB 文件时进程是没有办法响应新进入的请求的）
    3. 子进程为什么可以访问父进程的内存呢？
      1. 早期 UNIX 是直接完整复制一份父进程的内存给子进程，但是明显效率太低而且造成浪费，所以 Linux 采用了 Copy-on-write 技术来处理这个问题，这个技术核心思想就是刚 fork 出来，父子进程各自持有自己的虚拟空间，但是对应的物理空间是同一个，此时把内存页的权限设置为 read-only，当两个进程中的某一个尝试写操作时，触发 page-fault，触发 kernel 中断，kernel 把触发异常的页复制一份，父子进程各自持有独立的一份页，各自读写
    4. 什么时候会占多大的内存呢？
      1. 时机：执行BGSAVE（生成RDB、主从全量复制）、AOF REWRITE
      2. 占用量：
        1. 取决于子进程在执行写时复制操作过程中，当时写操作的量
        2. linux的大页机制（Transport Huge Pages），linux内存管理默认为4k，开启THP会变成2M（加速Copy-On-Write消耗）

一点小彩蛋：

redis进程的内存分配有三种内存分配器可供选择，具体的内存分配代码见zmalloc.c。redis并没有自己实现内存池，使用不同的内存分配器，性能不同，存储数据导致碎片率也会有所差异。Redis5.0源码中的README表示：Linux系统默认采用jemalloc内存分配器，因为相比libc大部分场景内存碎片率会更低（但实际上也跟数据息息相关，有些数据libc的碎片率反而更低）。

  1. tcmalloc
    1. Google推出的,https://github.com/gperftools/gperftools
  2. libc
    1. 标准的内存分配库malloc和free
  3. jemalloc
    1. facebook推出的,https://github.com/jemalloc/jemalloc

近期编译redis源码的时候，发现不同的架构，jemalloc的配置是不一样的。你看这里：

Amd64：-with-lg-page=12 --with-lg-hugepage=21

Arm64: --with-lg-page=16 --with-lg-hugepage=21

https://github.com/docker-library/redis/blob/master/5/Dockerfile

gnuArch="$(dpkg-architecture --query DEB_BUILD_GNU_TYPE)"; \
	extraJemallocConfigureFlags="--build=$gnuArch"; \
# https://salsa.debian.org/debian/jemalloc/-/blob/c0a88c37a551be7d12e4863435365c9a6a51525f/debian/rules#L8-23
	dpkgArch="$(dpkg --print-architecture)"; \
	case "${dpkgArch##*-}" in \
		amd64 | i386 | x32) extraJemallocConfigureFlags="$extraJemallocConfigureFlags --with-lg-page=12" ;; \
		*) extraJemallocConfigureFlags="$extraJemallocConfigureFlags --with-lg-page=16" ;; \
	esac; \
	extraJemallocConfigureFlags="$extraJemallocConfigureFlags --with-lg-hugepage=21"; \
	grep -F 'cd jemalloc && ./configure ' /usr/src/redis/deps/Makefile; \
	sed -ri 's!cd jemalloc && ./configure !&'"$extraJemallocConfigureFlags"' !' /usr/src/redis/deps/Makefile; \
	grep -F "cd jemalloc && ./configure $extraJemallocConfigureFlags " /usr/src/redis/deps/Makefile; \
快乐划水程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis参数说明
u010719917的专栏
03-20 253
##########ADVANCED CONFIG##########activerehashing yesaof-rewrite-incremental-fsync yesclient-output-buffer-limit normal 0 0 0 #该配置表示，对于 Pub/Sub 客户端来说，若 output-buffer 占用内存达到 32M 或者超过 8M 的时间达到 60s，则关闭客户端连接 client-output-buffer-limit pubsub 32mb 8mb 60client
redis-client.zip
11-19
redis客户端工具。
redis.conf 7.0 配置和原理全解，生产王者必备
码哥字节
11-07 2305
我是 Redis， 当程序员用指令 ./redis-server /path/to/redis.conf 把我启动的时候，第一个参数必须是redis.conf 文件的路径。这个文件很重要，就好像是你们的 DNA，它能控制我的运行情况，不同的配置会有不同的特性和人生，它掌握我的人生命运，控制着我如何完成高可用、高性能。合理的配置能让我更快、更省内存，并发挥我最大的优势让我更安全运行。以下这些配置大家...
Redis配置文件参数解释
xiaolinzi176的博客
02-27 2768
################################### NETWORK ################################### # 指定 redis 只接收来自于该IP地址的请求，如果不进行设置，那么将处理所有请求 bind 127.0.0.1 #是否开启保护模式，默认开启。要是配置里没有指定bind和密码。开启该参数后，redis只会本地进行访问， 拒绝外部访问。要是开启了密码和bind，可以开启。否则最好关闭，设置为no protected-mode yes ...
21 Redis 缓冲区的用法
热门推荐
海陆云的博客
12-09 2万+
21 Redis 缓冲区的用法前言一、客户端输入和输出缓冲区二、输入缓冲区溢出的应对方法三、输出缓冲区溢出的应对方法四、主从集群中的缓冲区总结 前言 缓冲区的功能是用一块内存空间来暂时存放命令数据，以免出现因为数据和命令的处理速度慢于发送速度而导致的数据丢失和性能问题。但因为缓冲区的内存空间有限，如果往里面写入数据的速度持续地大于从里面读取数据的速度，会导致缓冲区需要越来越多的内存来暂存数据。缓冲区占用的内存超出了设定的上限阈值时，会出现缓冲区溢出。 如果发生了溢出，会丢数据了。随着累积的数据越来越多，
Redis 性能调优——内存优化
一叶知秋的博客
07-31 3998
Redis 云平台 CacheCloud 提供一个Redis云管理平台：实现多种类型(Redis Standalone、Redis Sentinel、Redis Cluster)自动部署、解决Redis实例碎片化现象、提供完善统计、监控、运维功能、减少运维成本和误操作，提高机器的利用率，提供灵活的伸缩性，提供方便的接入客户端。
Redis 5.0.5配置文件 解读尝试
码地
10-22 1154
1、设置单位 当你需要为某个配置项指定内存大小的时候，可以指定类似于1k 5GB 4M等等这样的值来进行设置。 必须要带上单位，其转换方式如下（单位不区分大小写） 1k => 1000 bytes 1kb => 1024 bytes 1m => 1000000 bytes 1mb => 1024*1024 bytes 1g => 1000000000 by...
redis-配置文件
sanqianqingzhi的博客
01-11 655
redis.conf配置详解
六、Redis内存
L_D_Y_K的博客
01-08 1780
六、Redis内存 1、内存配置 (1)、内存设置 ①、如果不设置内存大小或者设置内存大小为0，在64位操作系统下不限制内存大小，在32位操作系统下最多使用3GB内存。 ②、Redis一般推荐设置内存为最大物理内存的四分之三。 (2)、修改文件配置 修改maxmemory大小，单位字节 (3)、通过命令修改 #修改内存大小 config set maxmemo...
Redis简介，设置redis内存大小，设置redis淘汰机制，查看内存占用情况，内存占用分析
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
07-28 3551
设置redis内存大小，设置redis淘汰机制，查看redis内存占用情况
学Redis这篇就够了
02-24
Redis是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库Redis与其他key-value缓存产品有以下三个特点：Redis支持数据持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。Redis...
高性能内存数据库Redis（基础篇）.pdf
11-21
该PPT主要涉及Redis简介、特性、HA和简单的应用场景等四块内容，整体上了解Redis的基础知识，适合入门读者了解Redis。
架构师成长之路Redis第一篇｜Redis 安装介绍以及内存分配器jemalloc
最新发布
08-28
Redis系列教程
高性能内存数据库Redis（基础篇）
11-21
高性能内存数据库Redis（基础篇）
redis集群系列二
快乐划水程序猿的专栏
06-26 3869
redis集群
redis集群系列一
快乐划水程序猿的专栏
05-14 1575
redis集群 redis集群模式是分布式存储的一个case。 数据分布 分布式数据库要解决将一堆数据按照分区规则映射到不同节点上。常见的分区规则有哈希分区和顺序分区。 分区方式 特点 产品 哈希分区 离散度好;数据分布与业务无关 redis cluster、cassandra 顺序分区 离散度容易倾斜；数据分布与业务有关；可以顺序访问 HBase、Hypertable 哈希分区 redis集群使用的是哈希分区，常见的哈希分区有以下几种： 节点取余 hash(key)/N， 但是
redis哨兵系列1
快乐划水程序猿的专栏
11-18 1422
redis哨兵知识
redis命令系列一
快乐划水程序猿的专栏
01-24 1058
redis常用命令
黑马redis原理篇
08-22
Redis是一种基于内存的高性能键值存储系统。它以其快速的读写能力和丰富的数据结构而闻名，被广泛应用于缓存、队列、计数器等场景。 Redis的核心原理包括以下几个方面： 1. 内存存储：Redis将数据存储在内存中，以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值