【Redis】05-Redis架构设计应用实践

最新推荐文章于 2024-04-30 17:25:22 发布
最新推荐文章于 2024-04-30 17:25:22 发布
阅读量154 收藏
点赞数
分类专栏： Redis缓存系统 文章标签： redis 数据库 docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43647307/article/details/120719079
版权

Redis主从复制

简介

单个Redis支持的读写能力还是有限的，此时我们可以使用多个Redis来提高Redis的并发处理能力，这些Redis如何协同，就需要有一定的架构设计，这里我们首先从主从(Master/Slave)架构进行分析和实现。

基本架构

redis主从架构如图所示：

在这里插入图片描述
其中，master负责读写，并将数据同步到slave，从节点负责读操作。

快速入门实践

基于Redis，设计一主从架构，一个Master，两个Slave，其中Master负责Redis读写操作，并将数据同步到Slave，Slave只负责读，其步骤如下：

第一：将redis01拷贝两份，例如：

cp -r redis01/ redis02

cp -r redis01/ redis03

在这里插入图片描述

第二步：假如已有redis服务，先将原先所有redis服务停止(docker rm -f redis容器名)，并启动新的redis容器，例如：

docker run -p 6400:6379 --name redis6400 \
-v /usr/local/docker/redis01/data:/data \
-v /usr/local/docker/redis01/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf \
--appendonly yes

docker run -p 6401:6379 --name redis6410 \
-v /usr/local/docker/redis02/data:/data \
-v /usr/local/docker/redis02/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf \
--appendonly yes

docker run -p 6402:6379 --name redis6402 \
-v /usr/local/docker/redis03/data:/data \
-v /usr/local/docker/redis03/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf \
--appendonly yes

在这里插入图片描述
在这里插入图片描述

第三步 检测redis服务角色

启动三个客户端，分别登陆三台redis容器服务，通过info指令进行角色查看，默认新启动的三个redis服务角色都为master。

127.0.0.1:6379> info replication

\# Replication
role:master
connected_slaves:0
master_repl_offset:3860
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:3859

在这里插入图片描述
第四步：检测redis6400的ip设置

docker inspect redis6400

[root@centos7964 ~]# docker inspect redis6400

……
"Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "c33071765cb48acb1efed6611615c767b04b98e6e298caa0dc845420e6112b73",
                    "EndpointID": "4c77e3f458ea64b7fc45062c5b2b3481fa32005153b7afc211117d0f7603e154",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }

在这里插入图片描述
第五步：设置Master/Slave架构

分别登陆redis6401/redis6402，然后执行如下语句

slaveof 172.17.0.2 6400

说明,假如master有密码,需要在slave的redis.conf配置文件中添加"masterauth 你的密码"这条语句,然后重启redis再执行slaveof 指令操作.

第六步：再次登陆redis6400，然后检测info

[root@centos7964 ~]# docker exec -it redis6379 redis-cli
127.0.0.1:6379> info replication

\# Replication
role:master
connected_slaves:2
slave0:ip=172.17.0.3,port=6400,state=online,offset=2004,lag=1
slave1:ip=172.17.0.4,port=6400,state=online,offset=2004,lag=1
master_failover_state:no-failover
master_replid:5baf174fd40e97663998abf5d8e89a51f7458488
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:2004
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:2004

第七步: 登陆redis6400测试，master读写都可以

[root@centos7964 ~]# docker exec -it redis6379 redis-cli
127.0.0.1:6379> set role master6379
OK
127.0.0.1:6379> get role
"master6379"
127.0.0.1:6379>

第八步: 登陆redis6401测试，slave只能读。

[root@centos7964 ~]# docker exec -it redis6380 redis-cli
127.0.0.1:6379> get role
"master6379"
127.0.0.1:6379> set role slave6380
(error) READONLY You can't write against a read only replica.
127.0.0.1:6379>

Java中的读写测试分析，代码如下：

@SpringBootTest
public class MasterSlaveTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testMasterReadWrite(){//配置文件端口为6379
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("role", "master6379");
        Object role = valueOperations.get("role");
        System.out.println(role);
    }

    @Test
    void testSlaveRead(){//配置文件端口为6380
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object role = valueOperations.get("role");
        System.out.println(role);
    }

}

主从同步原理分析

Redis的主从结构可以采用一主多从结构，Redis主从复制可以根据是否是全量分为全量同步和增量同步。

Redis全量同步

Redis全量复制一般发生在Slave初始化阶段，这时Slave需要将Master上的所有数据都复制一份。具体步骤如下：

1）从服务器连接主服务器，发送SYNC命令；

2）主服务器接收到SYNC命名后，开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令；

3）主服务器BGSAVE执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令；

4）从服务器收到快照文件后丢弃所有旧数据，载入收到的快照；

5）主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令；

6）从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；

Redis增量同步

Redis增量复制是指Slave初始化后，开始正常工作时主服务器发生的写操作同步到从服务器的过程。 增量复制的过程主要是主服务器每执行一个写命令就会向从服务器发送相同的写命令，从服务器接收并执行收到的写命令。

小节面试分析

如果redis要支持10万+的的并发你会怎么做？

单机的redis几乎不太可能说QPS超过10万+，除非一些特殊情况，比如你的机器性能特别好，配置特别高，物理机，维护做的特别好，而且你的整体的操作不是太复杂，一般的单机也就在几万。

真正实现redis的高并发，需要读写分离。对缓存而言，一般都是用来支撑读高并发的，写的请求是比较少的，可能写请求也就一秒钟几千。读的请求相对就会比较多,例如,一秒钟二十万次读。所以redis的高并发可以基于主从架构与读写分离机制进行实现。

Redis的replication机制是怎样的？

（1）redis采用异步方式复制数据到slave节点。

（2）一个master node是可以配置多个slave node的。

（3）slave node也可以连接其他的slave node。

（4）slave node做复制的时候，是不会block master node的正常工作的。

（5）slave node在做复制的时候，也不会block对自己的查询操作，它会用旧的数据集来提供服务; 但是复制完成的时候，需要删除旧数据集，加载新数据集，这个时候就会暂停对外服务了。

（6）slave node主要用来进行横向扩容，做读写分离，扩容的slave node可以提高读的吞吐量。

Redis哨兵模式

简介

哨兵（Sentinel）是Redis的主从架构模式下，实现高可用性（high availability）的一种机制。

由一个或多个Sentinel实例（instance）组成的Sentinel系统（system）可以监视任意多个主服务器，以及这些主服务器属下的所有从服务器，并在被监视的主服务器进入下线状态时，自动将下线主服务器属下的某个从服务器升级为新的主服务器，然后由新的主服务器代替已下线的主服务器继续处理命令请求。

基本架构

在这里插入图片描述

哨兵快速入门

第一步：分别进入3台redis容器内部进行配置，在容器指定目录/etc/redis创建sentinel.conf文件,文件内容为：

sentinel monitor redis6400 172.17.0.2 6400 1

其中, 如上指令表示要的监控的master。

  • redis6400为服务名

  • 172.17.0.2 和 6400 为master的 ip 和 端口，1表示多少个sentinel认为一个master失效时，master才算真正失效。

假如，这里如果出现 bash: vi: command not found，可依次执行如下两个指令来安装vim

apt-get update 
apt-get install vim

说明：假如网络不好，也可以在宿主机对应的挂载目录去创建文件，或者在容器中执行：

cat <<EOF > /etc/redis/sentinel.conf 
sentinel monitor redis6400 172.17.0.2 6400 1
EOF

第二步：在每个redis容器内部的/etc/redis目录下执行如下指令（最好是在多个客户端窗口执行），启动哨兵服务

redis-sentinel sentinel.conf

第三步：打开一个新的客户端连接窗口，关闭redis6400服务（这个服务是master服务）

docker stop redis6379

其它客户端窗口，检测日志输出，例如

410:X 11 Jul 2021 09:54:27.383 # +switch-master redis6379 172.17.0.2 6379 172.17.0.4 6379
410:X 11 Jul 2021 09:54:27.383 * +slave slave 172.17.0.3:6379 172.17.0.3 6379 @ redis6379 172.17.0.4 6379
410:X 11 Jul 2021 09:54:27.383 * +slave slave 172.17.0.2:6379 172.17.0.2 6379 @ redis6379 172.17.0.4 6379

第四步：登陆ip为172.17.0.4对应的服务进行info检测，例如：

127.0.0.1:6379> info replication

\# Replication
role:master
connected_slaves:1
slave0:ip=172.17.0.3,port=6400,state=online,offset=222807,lag=0
master_failover_state:no-failover
master_replid:3d63e8474dd7bcb282ff38027d4a78c413cede53
master_replid2:5baf174fd40e97663998abf5d8e89a51f7458488
master_repl_offset:222807
second_repl_offset:110197
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:29
repl_backlog_histlen:222779

从上面的信息输出发现，redis6402服务现在已经变为master。

Sentinel 配置进阶

对于sentinel.conf文件中的内容,我们还可以基于实际需求,进行增强配置,例如:

sentinel monitor redis6379 172.17.0.2 6400 1 
daemonize yes #后台运行
logfile "/var/log/sentinel_log.log" #运行日志
sentinel down-after-milliseconds redis6379 30000 #默认30秒

其中:

  1. daemonize yes表示后台运行(默认为no)

  2. logfile 用于指定日志文件位置以及名字

  3. sentinel down-after-milliseconds 表示master失效了多长时间才认为失效

哨兵工作原理分析

1)：每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令。

2)：如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值(这个配置项指定了需要多少失效时间，一个master才会被这个sentinel主观地认为是不可用的。 单位是毫秒，默认为30秒)， 则这个实例会被 Sentinel 标记为主观下线。

3)：如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。

4)：当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线 。

5)：在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令 。

6)：当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次 。

7)：若没有足够数量的 Sentinel 同意 Master 已经下线， Master 的客观下线状态就会被移除。

8): 若 Master 重新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。

Redis集群高可用

简述

Redis单机模式可靠性保证不是很好，容易出现单点故障，同时其性能也受限于CPU的处理能力，实际开发中Redis必然是高可用的，所以单机模式并不是我们的终点，我们需要对目前redis的架构模式进行升级。

Sentinel模式做到了高可用，但是实质还是只有一个master在提供服务(读写分离的情况本质也是master在提供服务)，当master节点所在的机器内存不足以支撑系统的数据时，就需要考虑集群了。

Redis集群架构实现了对redis的水平扩容，即启动N个redis节点，将整个数据分布存储在这N个redis节点中，每个节点存储总数据的1/N。redis集群通过分区提供一定程度的可用性，即使集群中有一部分节点失效或无法进行通讯，集群也可以继续处理命令请求。

基本架构

对于redis集群(Cluster)，一般最少设置为6个节点，3个master，3个slave，其简易架构如下：
在这里插入图片描述

创建集群

第一步：准备网络环境

创建虚拟网卡，主要是用于redis-cluster能于外界进行网络通信，一般常用桥接模式。

docker network create redis-net

查看docker的网卡信息，可使用如下指令

docker network ls

在这里插入图片描述

查看docker网络详细信息，可使用命令

docker network inspect redis-net

在这里插入图片描述

第二步：准备redis配置模板

mkdir -p /usr/local/docker/redis-cluster

在这里插入图片描述

cd /usr/local/docker/redis-cluster

vim redis-cluster.tmpl

在redis-cluster.tmpl中输入以下内容

port ${PORT}
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 192.168.126.128
cluster-announce-port ${PORT}
cluster-announce-bus-port 1${PORT}
appendonly yes

在这里插入图片描述
其中：

各节点解释如下所示：

  1. port：节点端口，即对外提供通信的端口
  2. cluster-enabled：是否启用集群
  3. cluster-config-file：集群配置文件
  4. cluster-node-timeout：连接超时时间
  5. cluster-announce-ip：宿主机ip
  6. cluster-announce-port：集群节点映射端口
  7. cluster-announce-bus-port：集群总线端口
  8. appendonly：持久化模式

第三步：创建节点配置文件

在redis-cluser中执行以下命令

for port in $(seq 8010 8015); \
do \
  mkdir -p ./${port}/conf  \
  && PORT=${port} envsubst < ./redis-cluster.tmpl > ./${port}/conf/redis.conf \
  && mkdir -p ./${port}/data; \
done

在这里插入图片描述

其中：

  • for 变量 in $(seq var1 var2);do …; done为linux中的一种shell 循环脚本, 例如：
[root@centos7964 ~]# for i in $(seq 1 5);
> do echo $i;
> done;
1
2
3
4
5
[root@centos7964 ~]#
  • 指令envsubst <源文件>目标文件,用于将源文件内容更新到目标文件中.

通过cat指令查看配置文件内容

cat /usr/local/docker/redis-cluster/801{0..5}/conf/redis.conf

在这里插入图片描述
第四步：创建集群中的redis节点容器

for port in $(seq 8010 8015); \
do \
   docker run -it -d -p ${port}:${port} -p 1${port}:1${port} \
  --privileged=true -v /usr/local/docker/redis-cluster/${port}/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  --privileged=true -v /usr/local/docker/redis-cluster/${port}/data:/data \
  --restart always --name redis-${port} --net redis-net \
  --sysctl net.core.somaxconn=1024 redis redis-server /usr/local/etc/redis/redis.conf; \
done

其中

–privileged=true表示让启动的容器用户具备真正root权限

–net redis-net 使用 redis-net 网络

–sysctl net.core.somaxconn=1024 这是一个linux的内核参数，用于设置请求队列大小，默认为128,后续启动redis的启动指令需要先放到这个请求队列中，然后依次启动。

创建成功以后，通过docker ps指令查看节点内容。

在这里插入图片描述
第五步：创建redis-cluster集群配置

docker exec -it redis-8010 bash

redis-cli --cluster create 192.168.126.128:8010 192.168.126.128:8011 192.168.126.128:8012 192.168.126.128:8013 192.168.126.128:8014 192.168.126.128:8015 --cluster-replicas 1

如上指令要尽量放在一行执行，其中最后的1表示主从比例，当出现选择提示信息时，输入yes即可。

第六步：连接redis-cluster，并添加数据到redis

redis-cli -c -h 192.168.227.131 -p 8010

在这里插入图片描述
其它：
在搭建过程，可能在出现问题后，需要停止或直接删除docker容器，可以使用以下参考命令

批量停止docker 容器：

docker ps -a | grep -i "redis-801*" | awk '{print $1}' | xargs docker stop

批量删除docker 容器：

docker ps -a | grep -i "redis-801*" | awk '{print $1}' | xargs docker rm -f

批量删除文件

rm -rf 801{0..5}/conf/redis.conf

以上就是基于docker搭建redis-cluster的简单步骤，实际应用中可能并没有这么简单，该文也仅用于参考。

Jedis集群中自带哨兵机制

进入redis8010

redis-cli -c -h 192.168.126.128 -p 8010

并通过info指令进行角色查看，其角色为master，其slave 为 redis8014

info replication

在这里插入图片描述

再进入redis8014查看角色信息，确实是redis8010的slave

在这里插入图片描述
此时关闭redis8010容器

在这里插入图片描述

再进入redis8014容器查看角色信息，发现redis8014已经由slave自动变为master

在这里插入图片描述

若再将redis8010容器启动，则redis8010会自动变成redis8014的slave

在这里插入图片描述

Jedis读写数据测试

public class testJedisCluster {
    @Test
    public void testJedisCluster()throws Exception{
        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(new HostAndPort("192.168.126.128",8010));
        nodes.add(new HostAndPort("192.168.126.128",8011));
        nodes.add(new HostAndPort("192.168.126.128",8012));
        nodes.add(new HostAndPort("192.168.126.128",8013));
        nodes.add(new HostAndPort("192.168.126.128",8014));
        nodes.add(new HostAndPort("192.168.126.128",8015));

        //定义连接池的配置
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(100);
        config.setMinIdle(60);
        JedisCluster jedisCluster = new JedisCluster(nodes,config);

        //使用jedisCluster操作redis
        jedisCluster.set("username", "Tony");
        String username = jedisCluster.get("username");
        System.out.println(username);

        //关闭连接池释放资源
        jedisCluster.close();
    }
}

在这里插入图片描述

RedisTemplate读写数据测试

第一步：配置application.yml,例如：

spring:
  redis:
    cluster: #redis 集群配置
      nodes: 192.168.126.128:8010,192.168.126.128:8011,192.168.126.128:8012,192.168.126.128:8013,192.168.126.128:8014,192.168.126.128:8015
      max-redirects: 3 #最大跳转次数
    timeout: 5000 #超时时间
    database: 0
    jedis: #连接池
      pool:
        max-idle: 8
        max-wait: 0

第二步：编写单元测试类，代码如下：

package com.cy.redis;
@SpringBootTest
public class RedisClusterTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void testMasterReadWrite(){
        //1.获取数据操作对象
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //2.读写数据
        valueOperations.set("city","beijing");
        Object city=valueOperations.get("city");
        System.out.println(city);
    }
}

小节面试分析

Redis的高并发跟整个系统的高并发是什么关系？

  1. Redis你要搞高并发的话，不可避免，要把底层的缓存搞得很好。例如，mysql的高并发，是通过一系列复杂的分库分表，订单系统，事务要求的，QPS到几万，比较高了。

  2. 要做一些电商的商品详情页，真正的超高并发，QPS上十万，甚至是百万，一秒钟百万的请求量，只有redis是不够的，但是redis是整个大型的缓存架构中，支撑高并发的架构里面，非常重要的一个环节。

  3. 你的底层的缓存中间件，缓存系统，必须能够支撑的起我们说的那种高并发，其次，再经过良好的整体的缓存架构的设计（多级缓存架构、热点缓存），支撑真正的上十万，甚至上百万的高并发。

总结（Summary）

本章节从redis高性能，高可靠性的角度对redis的主从架构，读写分离、哨兵机制、集群方式做了分析实践。这部分内容也是中大型项目中redis常用的一些架构设计方式。

李鲤驴。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis架构原理及应用实践
01-27
Redis是完全开源免费的，是一个高性能的key-value类型的内存数据库。整个数据库统统加载在内存当中进行操作，定期通过异步操作把数据库数据flush到硬盘上进行保存。因为是纯内存操作，Redis的性能非常出色，每秒可以...
redis架构
zhaozhenzuo的专栏
06-29 4778
一.redis竞品对比 存储 数据结构 持久化 集群可用性 网络模型 线程模型 redis 支持value是string,list,hash,set,zset 是 主从，redis cluster无中心分布式集群 非阻塞IO 单线程 无锁 memcache 只支持string 否 需要自行开发 基于twemproxy做 主从集群 非阻
Redis的架构模式
hellozhxy的博客
08-12 786
单机版 特点：简单 问题： 1、内存容量有限 2、处理能力有限 3、无法高可用。 主从复制 Redis 的复制（replication）功能允许用户根据一个 Redis 服务器来创建任意多个该服务器的复制品，其中被复制的服务器为主服务器（master），而通过复制创建出来的服务器复制品则为从服务器（slave）。 只要主从服务器之间的网络连接正常，主从服务器两者会具有相同的数据，主服务器就会一直将发生在自己身上的数据更新同步 给从服务器，从而一直保证主从服务器的数据相同。 特点： 1、
Redis多级缓存架构、缓存设计、布隆过滤器
玄霄
06-23 4388
Redis多级缓存架构、缓存设计、性能优化多级缓存架构缓存设计缓存穿透解决方法缓存雪崩解决方案 多级缓存架构 Nginx层：Lua动态渲染模板 一些静态资源、例如HTML、CSS、JS、图片资源等都可以独立部署在一台服务器上、加载进Redis缓存中。用户请求经过Nginx时、判断是否为静态资源、是则直接从静态资源服务器里面获取、不用经过后端的Web层和Redis集群； Web层缓存 Web层里面会有一些Ehcache缓存、可以使用HashMap、ConcurrentHashMap、ArrayList等数
【一文看懂 Redis 核心】 基础数据结构 & 架构设计 & 存储 & 集群
dying 搁浅
01-26 804
就是快，就是效率
redis架构设计
m0_58478012的博客
06-24 189
redis架构设计 一、 简介 高性能（目前已知性能最快） 读速度：110000 次 /s 写速度：81000 次 /s key-value（单个value的最大限制是1GB）类型的内存数据库 数据库在内存中进行操作 支持数据持久化 定期异步操作将数据库数据flush到硬盘上 支持string，list，set，sorted set，hash 操作都是原子性 支持事务 对数据的更改要么全部执行，要么全部不执行 事务中任意命令执行失败，其余命令依然被执行（Redis 事务不保证原子性，也不支持
Redis在企业级的应用实战-带书签
01-21
介绍Redis的复杂、高并发场景下的部署和架构实践
Redis如何分布式，来看京东金融的设计与实践
02-20
R2M是京东金融线上大规模应用的分布式缓存系统，目前管理的机器总内存容量超过60TB，近600个RedisCluster集群，9200多个Redis实例。其主要功能包括：全web可视化运维、缓存集群一键部署、资源池统筹管理、在线扩容及...
Redis架构设计实现
zhangzhangover的博客
10-12 973
Redis主从复制 单个redis读写能力有限 我们可以采用多个redis来提高处理并发能力 master负责读写,并将数据同步到slave ,从节点只负责读的操作 第一步: 将之前的redis01复制两份 让其作为slave cp -r redis01/ redis02 第二 步 将之前启动的redis服务删除 防止容器名重复 并启动新的容器 docker rm -f redis01 docker run -p 6379:6379 --name...
高可用 Redis 服务架构分析与搭建
好好学java
04-09 192
点击上方好好学java，选择星标公众号重磅资讯、干货，第一时间送达 今日推荐：牛人 20000 字的 Spring Cloud 总结，太硬核了~作者：Horstxu 出处：h...
redis架构图
12-25
redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
Redis架构设计分析
03-18
因为近期项目中开始使用Redis，为了更好的理解Redis并应用在适合的业务场景，需要对Redis设计与实现深入的理解。 我分析流程是按照从main进入，逐步深入分析Redis的启动流程。同时根据Redis初始化的流程，理解Redis各个模块的功能及原理。
Redis组件的架构设计，一篇文章带你了解
程序源日志的博客
01-18 222
方案3示意图中，红线部分是两台服务器之间的通信，而我们所设想的异常场景（【异常2】）是，某台服务器整体down机，不妨假设服务器1停机，此时，只剩下服务器2上面的Redis Sentinel和slave Redis Server进程。作为服务的提供方，我们总是会讲到用户体验问题。与此同时，在额外启动一个Sentinel进程，监控两个Redis Server实例的可用性，以便在master挂掉的时候，及时把slave提升到master的角色继续提供服务，这样就实现了Redis Server的高可用。
Redis：Redis整体架构
张豫湘的博客
04-07 329
根据key能够找到value存储的具体位置，redis不太一样，找到redis的value后，还需要从value的复杂接口（例如集合和列表）中找到具体的数据。不同的I/O模型对键值数据库的性能和可扩展性会有不同的影响。关于作者，目前在蚂蚁金服搬砖任职，在支付宝营销投放领域工作了多年，目前在专注于内存数据库相关的应用学习，如果你有任何技术交流或大厂内推及面试咨询，都可以从我的个人博客（由于redis的数据都保存在内存中，针对内存的随机访问的特性，哈希表O(1)的操作复杂度比较匹配。针对内存的分配和释放。
深度剖析不一样的Redis架构设计！
musicml的博客
11-17 165
- 01、不一样的Redis -提到Redis，大家一定会想到的几个点是什么呢？高并发、KV存储、内存数据库、丰富的数据结构、单线程（版本6之前）等。那么，接下来，上面提...
Redis - Set 集合
q322359的博客
04-24 934
集合类型可保存多个字符串类型的元素，但和列表类型不同的是，集合中的元素之间是（顺序不重要，变换一下集合中的数据顺序，集合不会发生改变） 的并且⼀个集合中最多可以存储 2^32-1 个元素。Redis 除了⽀持集合内的增删查改操作，同时还⽀持多个集合取交集、并集、差集，合理地使⽤好集合类型，能在实际开发中解决很多问题。
《Redis使用手册之有序集合》
最新发布
one大白(●—●)的博客
04-30 732
命令接受的分值范围与ZRANGEBYSCORE命令和ZCOUNT命令接受的分值范围一样，都默认为闭区间分值范围，但用户可以使用(符号定义闭区间，或者使用+inf和-inf表示正无限分值或负无限分值。处理不存在的键或者不存在的成员，ZINCRBY命令将直接把给定的成员添加到有序集合中，并把给定的增量设置为该成员的分值，效果相当于执行ZADD命令。在使用WEIGHTS选项时，用户需要为每个给定的有序集合分别设置一个权重，命令会将这个权重与成员的分值相乘，得出成员的新分值，然后进行聚合计算；
Redis知识点汇总表格总结
小蜜蜂1010的博客
04-27 1059
对面试中必问的Redis做了一个比较全面的汇总的知识点表格总结，对于复习Redis应对面试以及学习Redis都有一定的帮助
【Redis 开发】缓存穿透解决
weixin_62513677的博客
04-25 463
当数据库中查询无果的时候，我们在对应的缓存中写入一个null，在下一次访问的时候就不会到达数据库，由缓存返回一个null。首先通过布隆过滤器，如果没有数据就拒绝访问，底层时间通过数据库中的数据通过哈希算法算出哈希值存到布隆过滤器中。缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存就永远不会生效，这些请求都会打到数据库。可能造成短期的不一致 （我在数据库插入一条数据，但是对应的缓存中存的是null）在服务层判断数据库的时候加入缓存空对象方面的技术。优点：内存占用少，没有多余的key。
redis核心原理与实践pdf
07-15
《Redis核心原理与实践PDF》是一本介绍Redis的核心原理和实践的电子书，该书以清晰易懂的方式详细阐述了Redis的运作原理和实际应用。 首先，该书从Redis的基本概念入手，介绍了Redis的主要特性和优势。接着，它详细...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值