精华内容
下载资源
问答
  • redis高并发:主从架构,一主多从,一般来说,很多项目其实就足够了,单主用来写入数据,单机几万QPS,多从用来查询数据,多个从实例可以提供每秒10万的QPS。 redis高并发的同时,还需要容纳大量的数据:一主多从,...

    redis高并发:主从架构,一主多从,一般来说,很多项目其实就足够了,单主用来写入数据,单机几万QPS,多从用来查询数据,多个从实例可以提供每秒10万的QPS。

    redis高并发的同时,还需要容纳大量的数据:一主多从,每个实例都容纳了完整的数据,比如redis主就10G的内存量,其实你就最对只能容纳10g的数据量。如果你的缓存要容纳的数据量很大,达到了几十g,甚至几百g,或者是几t,那你就需要redis集群,而且用redis集群之后,可以提供可能每秒几十万的读写并发。

    redis高可用:如果你做主从架构部署,其实就是加上哨兵就可以了,就可以实现,任何一个实例宕机,自动会进行主备切换。

    redis 实现高并发主要依靠主从架构,一主多从.

    对于性能来说,单主用来写入数据,单机几万QPS,多从用来查询数据,多个从实例可以提供每秒 10w 的 QPS。

    如果想要在实现高并发的同时,容纳大量的数据,那么就需要 redis 集群。

     使用 redis cluster 模式,可以提供每秒几十万的读写并发。

    redis 高可用,如果是做主从架构部署,那么加上哨兵就可以了,就可以实现,任何一个实例宕机,可以进行主备切换。

    所以就有了几个问题?

    • 什么是主从架构,主从如何备份?

    • 什么是redis cluster模式?

    • 什么是哨兵集群?

    redis 主从架构

    主从(master-slave)架构,一主多从,主负责写,并且将数据复制到其它的 slave 节点,从节点负责读。所有的读请求全部走从节点。这样也可以很轻松实现水平扩容,支撑读高并发。

    Redis虽然读取写入的速度都特别快,但是也会产生读压力特别大的情况,所以为了缓解读的压力,所以进行读写分类,并对读进行扩展。

    优点:

    1、解决数据备份问题

    2、做到读写分离,提高服务器性能

    缺点:

    1、每个客户端连接redis实例的时候都是指定了ip和端口号的,如果所连接的redis实例因为故障下线了,而主从模式也没有提供一定的手段通知客户端另外可连接的客户端地址,因而需要手动更改客户端配置重新连接

    2、主从模式下,如果主节点由于故障下线了,那么从节点因为没有主节点而同步中断,因而需要人工进行故障转移工作

    3、无法实现动态扩容

    主从架构就涉及到一个数据从主节点同步到从节点的问题。涉及redis replication问题

    redis replication 的核心机制

    当启动一个 slave node 的时候,它会发送一个 PSYNC 命令给 master node,如果这是第一次连接master node 那么会触发一次 full resynchronization 全量复制.全量复制的时候,master 会启动一个后台线程,开始生成一份 RDB 快照文件,同时还会将从客户端新收到的所有写命令缓存在内存中。最后将生成的RDB文件发送给slave,slave会先写入本地磁盘,然后再从本地磁盘加载到内存中,接着 master 会将内存中缓存的写命令发送到 slave,slave 也会同步这些数据。

    如果是连接之后 master node 仅会复制给 slave 部分缺少的数据。master 如果发现有多个slave node都来重新连接,仅仅会启动一个rdb save操作,用一份数据服务所有slave node。

    注:redis2.8 开始,就支持主从复制的断点续传,如果主从复制过程中,断掉了,那么可以接着上次复制的地方,继续复制下去,而不是从头开始复制一份。 master node 会在内存中维护一个 backlog,master 和 slave 都会保存一个 replica offset 还有一个 master run id,offset 就是保存在 backlog 中的。如果 master 和 slave 网络连接断掉了,slave 会让 master 从上次 replica offset 开始继续复制,如果没有找到对应的 offset,那么就会执行一次 resynchronization。

    redis保证数据同步机制

    master和slave都会维护一个offset

    master会在自身不断累加offset,slave也会在自身不断累加offset slave每秒都会上报自己的offset给master,同时master也会保存每个slave的offset,检测offset来保证数据的一致性

    backlog

    master node有一个backlog,默认是1MB大小 master node给slave node复制数据时,也会将数据在backlog中同步写一份 backlog主要是用来做全量复制中断候的增量复制的

    master run id

    如果根据host+ip定位master node,是不靠谱的,如果master node重启或者数据出现了变化,那么slave node应该根据不同的run id区分,run id不同就做全量复制 如果需要不更改run id重启redis,可以使用redis-cli debug reload命令

    psync

    从节点使用psync从master node进行复制,psync runid offset。master node会根据自身的情况返回响应信息,可能是FULLRESYNC runid offset触发全量复制,可能是CONTINUE触发增量复制

    redis cluster 模式

    redis 服务节点中任何两个节点之间都是相互连通的。客户端可以与任何一个节点相连接,然后就可以访问集群中的任何一个节点。对其进行存取和其他操作。

    一般集群建议搭建三主三从架构,三主提供服务,三从提供备份功能。

    每一个节点都存有这个集群所有主节点以及从节点的信息。

    Redis集群数据分片

    在redis的每一个节点上,都有这么两个东西,一个是插槽(slot)可以理解为是一个可以存储两个数值的一个变量这个变量的取值范围是:0-16383。还有一个就是cluster我个人把这个cluster理解为是一个集群管理的插件。当我们的存取的key到达的时候,redis会根据crc16的算法得出一个结果,然后把结果对 16384 求余数,这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽,通过这个值,去找到对应的插槽所对应的节点,然后直接自动跳转到这个对应的节点上进行存取操作。

    投票过程是集群中所有master参与,如果半数以上master节点与master节点通信超时(cluster-node-timeout),认为当前master节点挂掉.

    什么时候整个集群不可用(cluster_state:fail)?

    如果集群任意master挂掉,且当前master没有slave.集群进入fail状态,也可以理解成集群的slot映射[0-16383]不完整时进入fail状态.

    一个Redis实例具备了“数据存储”和“路由重定向”,完全去中心化的设计。这带来的好处是部署非常简单,直接部署Redis就行,不像Codis有那么多的组件和依赖。但带来的问题是很难对业务进行无痛的升级,如果哪天Redis集群出了什么严重的Bug,就只能回滚整个Redis集群。

    优点:

    1、有效的解决了redis在分布式方面的需求

    2、遇到单机内存,并发和流量瓶颈等问题时,可采用Cluster方案达到负载均衡的目的

    3、可实现动态扩容

    4、P2P模式,无中心化

    5、通过Gossip协议同步节点信息

    6、自动故障转移、Slot迁移中数据可用

    缺点:

    1、架构比较新,最佳实践较少

    2、为了性能提升,客户端需要缓存路由表信息

    3、节点发现、reshard操作不够自动化

    redis 哨兵

    哨兵的功能:

    • 集群监控:负责监控 redis master 和 slave 进程是否正常工作。
    • 消息通知:如果某个 redis 实例有故障,那么哨兵负责发送消息作为报警通知给管理员。
    • 故障转移:如果 master node 挂掉了,会自动转移到 slave node 上。
    • 配置中心:如果故障转移发生了,通知 client 客户端新的 master 地址。

    哨兵用于实现 redis 集群的高可用,本身也是分布式的,作为一个哨兵集群去运行,互相协同工作。

    故障转移时,判断一个 master node 是否宕机了,需要大部分的哨兵都同意才行,涉及到了分布式选举的问题。

    即使部分哨兵节点挂掉了,哨兵集群还是能正常工作的。

    哨兵的核心知识

    • 哨兵至少需要 3 个实例,来保证自己的健壮性。
    • 哨兵 + redis 主从的部署架构,是不保证数据零丢失的,只能保证 redis 集群的高可用性。
    • 对于哨兵 + redis 主从这种复杂的部署架构,尽量在测试环境和生产环境,都进行充足的测试和演练。

    数据丢失问题的解决方案?

    进行如下配置: min-slaves-to-write 1 min-slaves-max-lag 10

    要求至少有 1 个 slave,数据复制和同步的延迟不能超过 10 秒。如果说一旦所有的 slave,数据复制和同步的延迟都超过了 10 秒钟,那么这个时候,master 就不会再接收任何请求了。

        减少异步复制数据的丢失
        有了 min-slaves-max-lag 这个配置,就可以确保说,一旦 slave 复制数据和 ack 延时太长,就认为可能 master 宕机后损失的数据太多了,那么就拒绝写请求,这样可以把 master 宕机时由于部分数据未同步到 slave 导致的数据丢失降低的可控范围内。
        减少脑裂的数据丢失
        如果一个 master 出现了脑裂,跟其他 slave 丢了连接,那么上面两个配置可以确保说,如果不能继续给指定数量的 slave 发送数据,而且 slave 超过 10 秒没有给自己 ack 消息,那么就直接拒绝客户端的写请求。
    

    怎么保证redis是高并发以及高可用的?

    1.sdown 和 odown 转换机制

    sdown 是主观宕机,就一个哨兵如果自己觉得一个 master 宕机了,那么就是主观宕机。odown 是客观宕机,如果 quorum 数量的哨兵都觉得一个 master 宕机了,那么就是客观宕机。

    sdown 达成的条件很简单,如果一个哨兵 ping 一个 master,超过了 is-master-down-after-milliseconds 指定的毫秒数之后,就主观认为 master 宕机了。sdown到odown转换的条件很简单,如果一个哨兵在指定时间内,收到了 quorum 数量的 其它哨兵也认为那个 master 是 sdown 的,那么就认为是 odown 了,客观认为master宕机。

    2.哨兵集群的自动发现机制

    哨兵互相之间的发现,是通过 redis 的 pub/sub 系统实现的,每个哨兵都会往sentinel:hello这个 channel 里发送一个消息,这时候所有其他哨兵都可以消费到这个消息,并感知到其他的哨兵的存在。 每隔两秒钟,每个哨兵都会往自己监控的某个 master+slaves 对应的sentinel:hello channel 里发送一个消息,内容是自己的 host、ip 和 runid 还有对这个 master 的监控配置。 每个哨兵也会去监听自己监控的每个 master+slaves 对应的sentinel:hello channel,然后去感知到同样在监听这个 master+slaves 的其他哨兵的存在。 每个哨兵还会跟其他哨兵交换对 master 的监控配置,互相进行监控配置的同步。

    3.slave 配置的自动纠正

    哨兵会负责自动纠正 slave 的一些配置,比如 slave 如果要成为潜在的 master 候选人,哨兵会确保 slave 复制现有 master 的数据; 如果 slave 连接到了一个错误的 master 上,比如故障转移之后,那么哨兵会确保它们连接到正确的 master 上。

    4.slave->master 选举算法

    如果一个 master 被认为 odown 了,而且 majority 数量的哨兵都允许主备切换,那么某个哨兵就会执行主备切换操作,此时首先要选举一个 slave 来,会考虑 slave 的一些信息:

        跟 master 断开连接的时长
        0slave 优先级
        复制 offset
        run id
    

    如果一个 slave 跟 master 断开连接的时间已经超过了down-after-milliseconds的 10 倍,外加 master 宕机的时长,那么 slave 就被认为不适合选举为 master。

    (down-after-milliseconds * 10) + milliseconds_since_master_is_in_SDOWN_state

    接下来会对 slave 进行排序:

    按照 slave 优先级进行排序,slave priority 越低,优先级就越高。 如果 slave priority 相同,那么看 replica offset,哪个 slave 复制了越多的数据,offset 越靠后,优先级就越高。 如果上面两个条件都相同,那么选择一个 run id 比较小的那个 slave。 

    5.quorum 和 majority

    每次一个哨兵要做主备切换,首先需要 quorum 数量的哨兵认为 odown,然后选举出一个哨兵来做切换,这个哨兵还得得到 majority 哨兵的授权,才能正式执行切换。 如果 quorum < majority,比如 5 个哨兵,majority 就是 3,quorum 设置为2,那么就 3 个哨兵授权就可以执行切换。 但是如果 quorum >= majority,那么必须 quorum 数量的哨兵都授权,比如 5 个哨兵,quorum 是 5,那么必须 5 个哨兵都同意授权,才能执行切换。

    6.configuration epoch

    哨兵会对一套 redis master+slaves 进行监控,有相应的监控的配置。 执行切换的那个哨兵,会从要切换到的新 master(salve->master)那里得到一个 configuration epoch,这就是一个 version 号,每次切换的 version 号都必须是唯一的。 如果第一个选举出的哨兵切换失败了,那么其他哨兵,会等待 failover-timeout 时间,然后接替继续执行切换,此时会重新获取一个新的 configuration epoch,作为新的 version 号。

    7.configuraiton 传播

    哨兵完成切换之后,会在自己本地更新生成最新的 master 配置,然后同步给其他的哨兵,就是通过之前说的 pub/sub 消息机制。 这里之前的 version 号就很重要了,因为各种消息都是通过一个 channel 去发布和监听的,所以一个哨兵完成一次新的切换之后,新的 master 配置是跟着新的 version 号的。其他的哨兵都是根据版本号的大小来更新自己的 master 配置的。

    展开全文
  • 2.1Redis支持的5种键值数据类型 2.2特点 2.3 Redis的应用场景 2.4redis简单应用 3.redis模拟高并发秒杀 学习redis之前,我们先了解NOSQL 1.NOSQL 1.1什么是NOSQL NOSQL是Not Only SQ...

    目录

    1.NOSQL

    1.1什么是NOSQL

    1.2应用场景:

    1.3主流NOSQL产品

    2.Redis

    2.1Redis支持的5种键值数据类型

    2.2特点

    2.3 Redis的应用场景

    2.4redis简单应用

    3.redis模拟高并发秒杀

     


     

    学习redis之前,我们先了解NOSQL

    1.NOSQL

    1.1什么是NOSQL

    NOSQL是Not Only SQL(不只是SQL)的意思,是一项全新的数据库理念,泛指非关系型数据库,如文件,非关系型数据库没有表/字段/记录的概念。

    旧理念:只能通过SQL语句操作数据库如:select * from tab_user;

    新理念:也可以通过非SQL方式操作数据库,即命令方式操作数据库如:hmget person username password gender

    1.2应用场景:

    1_万量级高并发读写的需求

    2_亿量级数据的查询的需求

    3_对数据库的可扩性的需求

     

    1.3主流NOSQL产品

    1_HandlerSocket

    2_Tokyo Cabinet

    3_MongoDB(市场主流)

    4_Redis(市场主流)

    5_HBase

     

    2.Redis

    2.1Redis支持的5种键值数据类型

    1_字符串类型(重点)

    2_散列/哈希/Map类型

    3_列表类型

    4_集合类型

    5_有序集合类型

     

    2.2特点

    特点:键值存储的数据库

    应用:内容缓存,主要用于处理大量数据的高访问

    优点:查询速度快

    缺点:存储数据时,采用的结构单一

     

     

    2.3 Redis的应用场景

    游戏下载注册登录等高并发场景

    商品秒杀系统等高并发场景

    商城页面的菜单购物车等高频率使用页面

    ....

     

    2.4redis简单应用

    首先要安装redis,自行百度。

    一下是redis-cli.exe中的命令,Jedis中也有着同样的命令,要牢记!

    //1.字符串存值
    set username "abc"
    //取值
    get username
    //取值再存值
    getset username "haha"
    //删值
    del username
    
    //2.存储hash/map类型
    //存一个值
    hset key username "aaa"
    hset key gender "male"
    //存多个值
    hmset key username "hellow" gender "male" sal 5000
    //根据key取一个值
    hget key username
    //根据key取多个值
    hmget key username gender
    //根据key取所有键值
    hgetall key
    //删除一个或多个field
    hdel key username gender salary
    //删除所有
    del key
    
    //3.存储list
    //从头部插入数据
    lpush key 1 2 3
    //从尾部插入数据
    rpush key one two three
    //查看列表,lrange key start end,-1表示倒数第一个元素
    lrange key 0 -1
    //弹出头部(left)第一个元素
    lpop key
    //弹出指尾部(right)第一个元素
    rpop key
    //获取元素的个数
    llen key
    
    //4.存储set类型
    //添加元素
    sadd key a b c
    //获取set中的所有元素 
    smembers key
    //删除元素
    srem key a b
    //判断元素是否在集合中存在
    sismember key a
    
    //5.存储sortedset类型,sortedset中每一个元素都会有一个分数(score)与之关联,分数/元素
    //添加元素
    zadd key 70 zhao 80 qian 90 shui
    //查询元素(从小到大)
    zrange key 0 -1    //获取集合中下标为start到end的元素,不带分数
    zrange key 0 -1 withscores    //获取集合中下标为start到end的元素,带分数
    //查询元素(从大到小)
    zrevrange key 0 -1    //按照元素分数从大到小,获取集合中下标为start到end的元素,不带分数
    zrevrange key 0 -1 withscores    //按照元素分数从大到小,获取集合中下标为start到end的元素,带分数
    //获取元素分数
    zscore key zhao
    //获取元素数量
    zcard key
    //删除元素
    zrem key shui zhao    //从集合中删除指定的元素
    //按照分数范围删除元素
    zremrangebyscore key 90 70

     

    3.redis模拟高并发秒杀

    package com.peixin.demo;
    
    import redis.clients.jedis.Jedis;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Demo1 {
    
        static Boolean isEmpty = false;
    
        public static void main(String[] args) {
           //模拟用户数量
            int userNumber = 500;
            //模拟从数据库读取商品数量
            int goodsNumber = 50;
    
            // TODO Auto-generated method stub
            //线程池,无限缓存线程池
            ExecutorService excutor = Executors.newCachedThreadPool();
            //连接本地的 Redis 服务
            Jedis jedis = new Jedis("127.0.0.1", 6379,100000);
            String ping = jedis.ping();
            if (ping.equalsIgnoreCase("PONG")) {
                System.out.println("redis缓存有效!" + ping);
            }
    
            String value = jedis.get("goods");
            if(value == null){
                System.out.println("无商品数据,开始添加!");
                //插入100个商品
                for(int i = 0;i<goodsNumber;i++){
                    jedis.lpush("goods", ""+i);
                }
            }
    
            //TODO 还要保证同一个用户不能秒杀两个
            Map<String,String> map = new HashMap<>();
            long length = jedis.llen("goods");
            System.out.println("商品剩余数量:"+length);
            //模拟秒杀代码
            CountDownLatch countDown = new CountDownLatch(userNumber);
            for (int i = 0; i < userNumber; i++) {
                final int index = i;
                excutor.execute( () ->{
                    System.out.println("用户 "+index+" 开始秒杀商品!");
                    //如果已经被抢完则直接拒绝后面的请求了。
                    if(isEmpty){
                        System.out.println("用户"+index+" 抱歉商品已秒杀完毕!");
                        countDown.countDown();
                        return;
                    }
                    Jedis checkJedis = new Jedis("localhost");
                    String result = checkJedis.lpop("goods");
                    //如果成功删除redis里的数据则表示抢到,如果存储数字则还需要事务控制并修改商品数字,比较影响性能,因此使用list比较好。
                    if(result!=null&&!result.equals("")){
                        System.out.println("用户 "+ index+" 成功抢到!");
                        map.put(index+"", result);
                    }else{
                        //只允许一个线程修改状态
                        synchronized (isEmpty) {
                            isEmpty = true;
                        }
                        System.out.println("用户 "+index+" 很遗憾你没有抢到,商品已秒杀完。");
                    }
                    checkJedis.close();
                    //表示一个线程执行完毕了
                    countDown.countDown();
                });
            }
            try {
                //等待所有线程执行完毕
                countDown.await();
                System.out.println("所有用户秒杀完毕,开始公布结果:");
                for (String key : map.keySet()) {
                    System.out.println("恭喜用户"+key+" 成功抢到!");
                }
                System.out.println("共"+map.size()+"位用户成功抢到。");
                jedis.close();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("done");
        }
    
    
    }

    模拟结果如下:

     

    忘记参考哪里了,修改了几处异常。

    如有侵权,请联系小编。

    展开全文
  • Redis高并发和快速原因 1.redis是基于内存的,内存的读写速度非常快; 2.redis是单线程的,省去了很多上下文切换线程的时间; 3.redis使用多路复用技术,可以处理并发的连接。非阻塞IO 内部实现采用epoll,采用...

    转自:https://www.jianshu.com/p/0bf46dd0aaf5

    参考:https://youzhixueyuan.com/reasons-for-redis-fast.html

    Redis的高并发和快速原因

    1.redis是基于内存的,内存的读写速度非常快;

    2.redis是单线程的,省去了很多上下文切换线程的时间;

    3.redis使用多路复用技术,可以处理并发的连接。非阻塞IO 内部实现采用epoll,采用了epoll+自己实现的简单的事件框架。epoll中的读、写、关闭、连接都转化成了事件,然后利用epoll的多路复用特性,绝不在io上浪费一点时间。

    下面重点介绍单线程设计和IO多路复用核心设计快的原因。

    为什么Redis是单线程的

    1.官方答案

    因为Redis是基于内存的操作,CPU不是Redis的瓶颈,Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现,而且CPU不会成为瓶颈,那就顺理成章地采用单线程的方案了。

    2.性能指标

    关于redis的性能,官方网站也有,普通笔记本轻松处理每秒几十万的请求。

    3.详细原因

    1)不需要各种锁的性能消耗

    Redis的数据结构并不全是简单的Key-Value,还有list,hash等复杂的结构,这些结构有可能会进行很细粒度的操作,比如在很长的列表后面添加一个元素,在hash当中添加或者删除
    一个对象。这些操作可能就需要加非常多的锁,导致的结果是同步开销大大增加。
    总之,在单线程的情况下,就不用去考虑各种锁的问题,不存在加锁释放锁操作,没有因为可能出现死锁而导致的性能消耗。

    2)单线程多进程集群方案

    单线程的威力实际上非常强大,每核心效率也非常高,多线程自然是可以比单线程有更高的性能上限,但是在今天的计算环境中,即使是单机多线程的上限也往往不能满足需要了,需要进一步摸索的是多服务器集群化的方案,这些方案中多线程的技术照样是用不上的。

    所以单线程、多进程的集群不失为一个时髦的解决方案。

    3)CPU消耗

    采用单线程,避免了不必要的上下文切换和竞争条件,也不存在多进程或者多线程导致的切换而消耗 CPU。

    但是如果CPU成为Redis瓶颈,或者不想让服务器其他CUP核闲置,那怎么办?

    可以考虑多起几个Redis进程,Redis是key-value数据库,不是关系数据库,数据之间没有约束。只要客户端分清哪些key放在哪个Redis进程上就可以了。

    Redis单线程的优劣势

    1.单进程单线程优势

    1. 代码更清晰,处理逻辑更简单
    2. 不用去考虑各种锁的问题,不存在加锁释放锁操作,没有因为可能出现死锁而导致的性能消耗
    3. 不存在多进程或者多线程导致的切换而消耗CPU

    2.单进程单线程弊端

    1. 无法发挥多核CPU性能,不过可以通过在单机开多个Redis实例来完善;

    IO多路复用技术

    redis 采用网络IO多路复用技术来保证在多连接的时候, 系统的高吞吐量。

    多路-指的是多个socket连接,复用-指的是复用一个线程。多路复用主要有三种技术:select,poll,epoll。epoll是最新的也是目前最好的多路复用技术。

    这里“多路”指的是多个网络连接,“复用”指的是复用同一个线程。采用多路
    I/O
    复用技术可以让单个线程高效的处理多个连接请求(尽量减少网络IO的时间消耗),且Redis在内存中操作数据的速度非常快(内存内的操作不会成为这里的性能瓶颈),主要以上两点造就了Redis具有很高的吞吐量。

    Redis高并发快总结

    1. Redis是纯内存数据库,一般都是简单的存取操作,线程占用的时间很多,时间的花费主要集中在IO上,所以读取速度快。

    2. 再说一下IO,Redis使用的是非阻塞IO,IO多路复用,使用了单线程来轮询描述符,将数据库的开、关、读、写都转换成了事件,减少了线程切换时上下文的切换和竞争。

    3. Redis采用了单线程的模型,保证了每个操作的原子性,也减少了线程的上下文切换和竞争。

    4. 另外,数据结构也帮了不少忙,Redis全程使用hash结构,读取速度快,还有一些特殊的数据结构,对数据存储进行了优化,如压缩表,对短数据进行压缩存储,再如,跳表,使用有序的数据结构加快读取的速度。

    5. 还有一点,Redis采用自己实现的事件分离器,效率比较高,内部采用非阻塞的执行方式,吞吐能力比较大。

    展开全文
  • Redis如何支持高并发 Redis 主从架构(master-slave) + Redis 读写分离 Redis 集群架构做成主从架构,一主多从。主负责写,并负责将数据同步到其他的salve 节点上,从负责读,所有的读请求走从节点 这样不仅能支持...

    Redis如何支持高并发

    Redis 主从架构(master-slave) + Redis 读写分离

    Redis 集群架构做成主从架构,一主多从。主负责写,并负责将数据同步到其他的salve 节点上,从负责读,所有的读请求走从节点

    这样不仅能支持高并发还能很轻易的进行水平扩容,只需要在扩容 slave 节点就好了

    Redis replication 主从同步基本原理

    1. redis 采用异步复制的方法进行复制,现在好像是 slave node 会周期性的确认一下自己每次复制的数据量
    2. 一个master node 可以有多个 salve node
    3. slave node 可以链接其他的 slave node
    4. slave node 做复制的时候不会阻塞 master的工作
    5. slave node 进行复制的时候不会阻塞自己的读操作,会使用旧数据,等同步完成删除旧数据,在使用新数据
    6. slave node 可以做水平扩容进而支持高并发

    为什么主从架构必须要开启持久化机制

    当master 宕机之后,如果没=没有开启持久化,那么master上的数据是空的,如果在经过复制之后 slave 节点的数据也全部为空

    就算是哨兵自主选择了 master,在启动之后原 master节点也会丢失部分数据,即便是这样,还是会存在哨兵还没有检测到 master failure,master 自己重启了,还是会导致所有的数据清空

    Redis 如何将 master 数据复制到 slave 上

    master 将数据复制到 slave 上一般有全量复制和增量复制两种操作

    全量复制一般出现在 slave 初始化节点
    增量复制一般是 slave 中已经有了 master 的部分数据,但是因为某种原因和master 断开了链接,之后又重连上了

    主从复制原理:

    1. 一个slave 链接到 master 的时候会给 master 发送一个 sync 命令
    2. master 接收到命令之后就会将数据生成快照文件,并且在缓冲区记录之后的写操作
    3. master 将生成的快照文件发送给所有的从节点
    4. 从节点接收到新的快照文件之后丢弃旧数据,载入新数据
    5. 主节点快照发送完成之后就会将之后的写操作发送给从服务器
    6. 从服务器执行主节点发送过来的写命令

    在这里插入图片描述

    主从复制的断点续传

    中途断网导致没有一次性传输完成,在连接之后还会在断点处继续传输

    原理: master 节点会在内存中创建一个 backlog 的日志文件,backlog 文件中会有一个 raplica offset 来记录传输到哪里,当链接之后,salve 就会要求 master 从 replica offset 出传输

    过期 key 的处理

    slave 不会过期 key,只有当 master 过期 key 之后,master 会模拟一条del命令发送给slave

    Redis 如何实现高可用

    通过哨兵 + Redis 主从架构 进行故障转移


    参考博客:https://www.cnblogs.com/daofaziran/p/10978628.html

    展开全文
  • redis特点:居于内存读写,支持高并发适合用来做缓存,而且是单线程执行命令,没有线程安全问题,本文将针对redis单线程执行命令的特点介绍几个用途。 1. 用来做计数器 高并发的情况下统计每个音频的播放量,这样的...
  • 一、Redis为什么快 纯内存K-V操作 数据库的工作模式按存储方式分为了磁盘数据库和内存数据库。Redis将数据存储在内存中,并且绝大多数命令都不会受到磁盘 IO 速度的限制,所以速度极快。此外,Redis内部采用了 ...
  • 基于redis高并发投票设计

    万次阅读 2018-04-30 19:51:49
    各大机构,学校,企事业单位,都采用这种方式,评选。已达到推广,或者什么目的地吧。...公司目前有做好的产品,但没有用Nosql,到时候肯定无法支持,所以,要重构。现有数据表中,报名量在 4千多,投票记录是...
  • 原文链接:...tid=229629 ...作为一名PHP工程师对于这种架构已经非常的熟悉了,目前站点并发并不是很,线上环境使用的是阿里云主机,1.5G的内存,PHP并发支持400~500...
  • 1.单线程,不存在进程切换影响cpu速度 2.纯内存操作 3.使用多路I/O复用模型,非阻塞IO 多路I/O复用模型是利用 select、poll、epoll 可以同时监察多个流的 I/O 事件的能力,在空闲的时候,会把当前线程阻塞掉,当...
  • 一.Redis高并发和快速原因 1.redis是基于内存的,内存的读写速度非常快; 2.redis是单线程的,省去了很多上下文切换线程的时间; 3.redis使用多路复用技术,可以处理并发的连接。非阻塞IO 内部实现采用epoll,...
  • 前段时间学习点Redis,这次结合ssm实现一个高并发抢红包的项目。跟以前不一样的: 基于java配置SSM,而并非XML.为什么要这样呢?找了点网络上的答案: 在使用Spring开发时,我们经常会看到各种各样xml配置,过于繁多...
  • 支持诸如字符串、散列、列表、集合、带有范围查询的排序集、位图、日志、带有半径查询的地理空间索引和流之类的数据结构。Redis具有内置的复制、Lua脚本、LRU驱逐、事务和不同级别的磁盘持久性,...
  • 1、基本原理 采用多路 I/O 复用技术可以让单个线程高效的处理多个连接请求(尽量减少网络IO的时间消耗) (1)为什么不采用多进程或多线程处理? 多线程处理可能涉及到锁 ...Redis采用了线程封闭的方式,把任...
  • 3. Redis如何支持高并发? 1. 学习内容 (1)Redis高并发和系统的高并发有什么关系? (2)Redis如何支撑高并发? 2. Redis高并发和系统的高并发有什么关系? 大型电商系统中,像商城首页,商品详情页,高峰时期,...
  • redis高并发架构

    2020-02-19 11:34:49
    redis使用过程主要考虑:高并发、高可用、持久性几个方面 高并发 单节点redis通常能够支持1w到几万的,假如单节点实力能够支撑5w的qps 问题1:如何用redis支撑10万的读qps? 分为两种情况来考虑: 1、数据量单节点...
  • 申明 本文章首发自本人公众号:壹枝花算不算浪漫,如若转载请标明来源! 感兴趣的小伙伴可关注个人...Redis如何支持高并发 单机的redis一般QPS不会超过超过10万+,一般单机QPS都在几万左右,如果需要支撑高并发,...
  • 前段时间学习点Redis,这次结合ssm实现一个高并发抢红包的项目。跟以前不一样的: 基于java配置SSM,而并非XML.为什么要这样呢?找了点网络上的答案: 在使用Spring开发时,我们经常会看到各种各样xml配置,过于繁多...
  • redis高并发原理1.概述 为了使Redis具有高可用性,我们可以使用Spring Data RedisRedis Sentinel的支持。 使用Sentinel,我们可以创建可自动抵抗某些故障的Redis部署。 Redis Sentinel还提供其他附带任务,例如...
  • 1、主从结构支持高并发 我们使用redis缓存,主要目的是为了读的高并发,所以可以采用一主多从,读写分离,master负责写,写完后异步将数据复制到slave中,slave负责分担读请求 redis replication 原理 (1)redis...
  • 申明本文章首发自本人公众号:壹枝花算不算浪漫,如若转载请标明来源!...Redis如何支持高并发单机的redis一般QPS不会超过超过10万+,一般单机QPS都在几万左右,如果需要支撑高并发,我们可以将Redis做成...
  • 在数据的完整性方面有更支持,如果设置file的时间是1s,那么redis发生故障,只会丢失1s的数据。 并且如果日志出现问题,可以使用redis-check-aof来进行修复。 缺点 AOF文件比RDB文件大,并且恢复速度慢,因为它...
  • 1.redis概述redis是一个开源的,先进的 key-value 存储可用于构建性能的存储解决方案。它支持数据结构有字符串,哈希,列表,集合,带有范围查询的排序集,位图,超文本和具有半径查询的地理空间索引。NoSQL,Not ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,679
精华内容 671
关键字:

redis支持高并发

redis 订阅