精华内容
下载资源
问答
  • Redis 高并发原理

    千次阅读 2017-12-14 12:18:58
    1 单线程模型 Redis客户端对服务端的每次调用都经历了发送命令,执行命令,返回结果三个过程。...但是可以确定的是不会有两条命令被同时执行,不会产生并发问题,这就是Redis的单线程基本模型。 2 单线程模...

    1 单线程模型

    Redis客户端对服务端的每次调用都经历了发送命令,执行命令,返回结果三个过程。其中执行命令阶段,由于Redis是单线程来处理命令的,所有每一条到达服务端的命令不会立刻执行,所有的命令都会进入一个队列中,然后逐个被执行。并且多个客户端发送的命令的执行顺序是不确定的。但是可以确定的是不会有两条命令被同时执行,不会产生并发问题,这就是Redis的单线程基本模型。

    2 单线程模型每秒万级别处理能力的原因

    (1)纯内存访问。数据存放在内存中,内存的响应时间大约是100纳秒,这是Redis每秒万亿级别访问的重要基础。

    (2)非阻塞I/O,Redis采用epoll做为I/O多路复用技术的实现,再加上Redis自身的事件处理模型将epoll中的连接,读写,关闭都转换为了事件,不在I/O上浪费过多的时间。

    (3)单线程避免了线程切换和竞态产生的消耗。

    (4)Redis采用单线程模型,每条命令执行如果占用大量时间,会造成其他线程阻塞,对于Redis这种高性能服务是致命的,所以Redis是面向高速执行的数据库。

    展开全文
  • redis高并发原理 在本文中,我们将讨论Redis SORT命令。 Redis提供了SORT命令,我们可以使用该命令从LIST,SET或ZSET中检索或存储排序的值。 我们可以使用最简单的形式在KEY上使用命令,如下例所示: SORT ...
    redis高并发原理

    redis高并发原理

    在本文中,我们将讨论Redis SORT命令。

    Redis提供了SORT命令,我们可以使用该命令从LIST,SET或ZSET中检索或存储排序的值。

    我们可以使用最简单的形式在KEY上使用命令,如下例所示:

    SORT numbers_list

    这将对键中包含的值进行排序并返回它们。 该命令将值按数字排序。 因此,可以说我们有一个包含以下值的列表:

    1, 110, 5

    上面的命令将返回

    1 5 110

    我们可以指定使用ALPHA修饰符按字母顺序对值进行排序。 有许多修饰符。 我们将在下面的示例中查看其中的一些。 这些示例将使用Jedis api。

    对于我们的示例,让我们考虑一下我们有一个想法管理系统。 我们有一个列表,其中包含系统中的所有用户名:

    all:users [junior, francisco, ribeiro, user4]

    对于每个用户名,将有一个包含用户信息的哈希:

    user:
    
    user:junior
      - name: "Junior User"
      - num_ideas : "5"
      - email:"fjunior@email.com"
    
    user:francisco
     - name: "Francisco User"
     - num_ideas: "4"
     - email: "francisco@email.com"
    
    ...

    我们可以为我们的示例看到一个将填充redis的类:

    package br.com.xicojunior.redistest;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import redis.clients.jedis.Jedis;
    
    public class App 
    {
    
        public static Jedis jedis = new Jedis("localhost");   
        public static void main( String[] args ){
    
        	String names[] = new String[]{"junior", "francisco", "ribeiro", "user4"};
        	for(String name: names){
        		jedis.lpush("all:users", name);
        	}
        	addUserHash(names[0], "Junior User", "junior@junior.com", "5");
        	addUserHash(names[1], "Francisco User", "francisco@francisco.com", "4");
        	addUserHash(names[2], "Ribeiro User", "ribeiro@ribeiro.com", "3");
        	addUserHash(names[3], "User 4", "user@user.com", "2");
    
        	for(String name: names){
        		System.out.println(jedis.hgetAll("user:".concat(name)));
        	}
    
        	System.out.println(jedis.lrange("all:users", 0, -1));
    
        }
    
        public static void addUserHash(String username, String name, String email, String numberOfIdeas){
        	Map<String, String> userProp = new HashMap<String, String>();
        	userProp.put("name",name);
        	userProp.put("email", email);
        	userProp.put("num_ideas", String.valueOf(numberOfIdeas));
    
        	jedis.hmset("user:".concat(username), userProp);
        }
    }

    让我们看下面的代码示例:

    package br.com.xicojunior.redistest;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.SortingParams;
    
    public class SortTest {
    
    	public static void main(String[] args) {
    		Jedis jedis = new Jedis("localhost");
    
    		//[1]sorting the usernames
    		System.out.println(jedis.sort("all:users"));
    		//[ribeiro, francisco, junior, user4]
    
    		//[2]sorting the username alpha
    		//jedis sort method receives a SortingParams instance for modifiers
    		System.out.println(jedis.sort("all:users", new SortingParams().alpha()));
    		//[francisco, junior, ribeiro, user4]
    
    	}
    
    }

    在上面的示例中,我们对键“ all:users ”进行排序。 在第一次尝试中,它似乎没有正确排序,因为默认排序考虑了数字。 在第二个示例中,我们使用ALPHA修饰符。 我们可以通过使用sort方法的重载版本来做到这一点。 它接收SortingParams类的实例。 在这种情况下,我们看到用户名已正确排序。

    SORT命令的一个不错的功能是我们可以使用外部值(其他键中的值)对列表进行排序。 在下面的示例中,我们将按用户给出的建议数目对all:users键进行排序。 可以使用“ BY ”修饰符来完成,该修饰符接收要使用的键的模式。 让我们来看下面的示例:

    package br.com.xicojunior.redistest;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.SortingParams;
    
    public class SortTest {
    
    	public static void main(String[] args) {
    		Jedis jedis = new Jedis("localhost");
    
    		//[1] Sorting the usernames by the number of ideas
    		System.out.println(jedis.sort("all:users", new SortingParams().by("user:*->num_ideas")));
    		//[user4, ribeiro, francisco, junior]
    
    		//[1] Sorting the usernames by the number of ideas DESC
    		System.out.println(jedis.sort("all:users", new SortingParams().by("user:*->num_ideas").desc()));
    	}
    
    }

    在第二个示例中,我们通过一个外部值对用户名进行排序,在本例中,我们使用字段“ num_ideas ”进行排序 在这种情况下,我们使用哈希字段进行排序,我们使用以下模式“ user:*-> num_ideas ”。 使用这种模式,我们要寻找键“ user:* ”,其中的“ *”将被列表中的值替换。 由于它是一个散列,因此我们需要通知该字段,因此我们使用模式“ -> fieldname ”进行操作。 如果我们按字符串键进行排序,则可以使用以下模式“ num_ideas_ * ”,因为有一个键可以存储每个用户的想法数。

    在第一次调用它检索排序ASC他们的价值观,我们也可以告诉Redis的对它进行排序DESC使用DESC修改。 jedis BY和DESC是SortingParams中的方法。 当所有方法都返回实例时,我们可以链接所有调用,这使得读取代码更加容易。

    使用SORT命令,我们还可以从外部键或来自外部哈希的字段中检索值。 我们可以使用GET修饰符执行此操作,并且可以多次使用它。 让我们在下面看到此修饰符的一些示例:

    package br.com.xicojunior.redistest;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.SortingParams;
    
    public class SortTest {
    
    	public static void main(String[] args) {
    		Jedis jedis = new Jedis("localhost");
    
    		//[1] Sorting the usernames by the number of ideas and retrieving the user name
    		System.out.println(jedis.sort("all:users", new SortingParams().by("user:*->num_ideas").get("user:*->name")));
    		//[User 4, Ribeiro User, Francisco User, Junior User]
    
    		//[2] Retrieving the name and email
    		System.out.println(jedis.sort("all:users", new SortingParams().by("user:*->num_ideas").get("user:*->name","user:*->email")));
    		//[User 4, user@user.com, Ribeiro User, ribeiro@ribeiro.com, Francisco User, francisco@francisco.com, Junior User, junior@junior.com]
    
    		//[3] Retrieve the value of the key being sorted - Special pattern #
    		System.out.println(jedis.sort("all:users", new SortingParams().by("user:*->num_ideas").get("user:*->name","user:*->email","#")));
    		//[User 4, user@user.com, user4, Ribeiro User, ribeiro@ribeiro.com, ribeiro, Francisco User, francisco@francisco.com, francisco, Junior User, junior@junior.com, junior]
    	}
    
    }

    在上面的代码中,我们可以看到GET修饰符的使用,为了返回散列字段,我们可以使用一种类似于在BY修饰符中使用的模式。 如前所述,在第一个示例中,我们仅返回名称,我们可以多次使用GET;在第二个示例中,我们从用户那里检索名称和电子邮件。 我们还可以检索使用特殊模式“#”排序的键的值。 方法get,接收一个变量,因此我们可以传递要从中检索值的所有外部键。

    我们可以做的另一件事是将排序结果存储在一个键中。 在需要缓存排序结果的情况下很有用,我们可以为sort命令指定一个dest键。 结果将存储为LIST。

    package br.com.xicojunior.redistest;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.SortingParams;
    
    public class SortTest {
    
    	public static void main(String[] args) {
    		Jedis jedis = new Jedis("localhost");
    
    		jedis.sort("all:users","dest_key1");
    
    		System.out.println(jedis.lrange("dest_key1", 0, -1));
    		//[ribeiro, francisco, junior, user4]
    
    		jedis.sort("all:users", new SortingParams().alpha().desc(), "dest_key2");
    
    		System.out.println(jedis.lrange("dest_key2", 0, -1));
    		//[user4, ribeiro, junior, francisco]
    	}
    
    }

    SORT命令的一个非常有用的功能是我们只能将其用于从相关键中获取值。 有一个修饰符,指示不对NOSORT进行排序

    package br.com.xicojunior.redistest;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.SortingParams;
    
    public class SortTest {
    
    	public static void main(String[] args) {
    		Jedis jedis = new Jedis("localhost");
    
    		System.out.println(jedis.sort("all:users", new SortingParams().get("user:*->name","user:*->email").nosort()));
    		//[User 4, user@user.com, Ribeiro User, ribeiro@ribeiro.com, Francisco User, francisco@francisco.com, Junior User, junior@junior.com]
    
    	}
    
    }

    这段代码基本上为所有用户检索名称和电子邮件。 如果我们不使用SORT命令,则至少需要两个命令来执行相同的操作:

    LRANGE all:users 0 -1 //TO get all usernames

    然后为每个用户名分别调用hmget,如下所示

    HMGET user:junior name email //TO get the name and email from a user
    • 我们可以在redis站点中找到命令文档。
    参考:XICO JUNIOR'S WEBLOG博客中,我们JCG合作伙伴Francisco Ribeiro Junior的Jedis与Redis进行了排序

    翻译自: https://www.javacodegeeks.com/2014/02/redis-sort-with-jedis.html

    redis高并发原理

    展开全文
  • redis高并发原理1.概述 为了使Redis具有高可用性,我们可以使用Spring Data Redis对Redis Sentinel的支持。 使用Sentinel,我们可以创建可自动抵抗某些故障的Redis部署。 Redis Sentinel还提供其他附带任务,例如...
    redis高并发原理

    redis高并发原理

    1.概述

    为了使Redis具有高可用性,我们可以使用Spring Data Redis对Redis Sentinel的支持。 使用Sentinel,我们可以创建可自动抵抗某些故障的Redis部署。

    Redis Sentinel还提供其他附带任务,例如监视,通知,并充当客户端的配置提供程序。

    在较高级别,Sentinel的功能是:

    • 自动故障转移 当主服务器无法正常工作时,Sentinel会为我们启动故障转移过程,将从服务器升级为主服务器。 此外,其他从属服务器也被重新配置为使用新的主服务器,并且使用Redis服务器的应用程序将被告知要使用的新地址。
    • 配置源 当发生故障转移时,Sentinels将报告新地址。 这是因为Sentinel充当客户端的权威来源。 客户端进行服务发现时,它们会连接到Sentinels,以请求负责给定服务的当前Redis主服务器的地址。
    • 监控 Sentinel会定期检查我们的主实例和从实例是否按预期工作。
    • 通知 可以将Sentinel配置为在Redis实例之一发生错误时通知各种目标。 这些目标包括其他应用程序,系统管理员或API。

    2.如何运行前哨

    自Redis 2.8起,Redis附带了Sentinel的稳定版本。

    启动Sentinel非常容易。 当我们在上一篇文章中回顾Spring Data Redis(使用Spring Boot)时,我们在Mac上使用自制软件安装了Redis。 此命令使我们可以在该安装中运行Sentinel:

    redis-sentinel /path/to/sentinel.conf

    如果我们使用的是redis-sentinel可执行文件(或者如果有一个使用该名称的符号链接到redis-server的可执行文件),那么我们也可以使用上述命令来运行Sentinel。

    另外,我们可以使用redis-server可执行文件并以Sentinel模式启动它,如下所示:

    redis-server /path/to/sentinel.conf --sentinel

    3.部署Sentinel之前需要了解的关键概念

    在部署到Sentinel之前,我们应该检查的一些概念包括:

    1. 我们至少需要三个Sentinel实例才能进行持久的Redis部署。
    2. 我们应该将三个Sentinel实例放置在据信会独立而不是一起失败的计算机或虚拟机中。 例如,这可能意味着不同的可用性区域。
    3. Redis使用异步复制,因此即使在使用Sentinel时,Redis也不能保证在故障期间会保持接收到的写入。 但是,我们可以部署Sentinel来减少写入丢失的时间。
    4. 任何高可用性设置都必须定期进行测试,并且Sentinel不变。 我们需要在开发环境和生产环境中进行测试。 通过计划和测试故障,我们可以限制故障。

    4. Spring数据中的配置

    当我们使用基于Sentinels的配置时,我们不会向Spring Data Redis提供Redis主机/端口信息。 相反,我们提供了主服务器的属性和Sentinel URL列表。 每个Sentinel进程都有自己的配置文件,该文件列出了主Redis服务器,例如:

    sentinel monitor themaster 127.0.0.1 6379 2
    sentinel down-after-milliseconds themaster 60000
    sentinel failover-timeout themaster 180000
    sentinel parallel-syncs themaster 1

    一旦配置好了主服务器,从服务器和Sentinels,就需要在应用程序中更改spring数据redis配置,以与前哨一起使用。

    4.1 Java配置

    可以使用Jedis和Lettuce来完成Java配置:

    /**
     * Jedis
     */
    @Bean
    public RedisConnectionFactory jedisConnectionFactory() {
      RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
      .master("themaster")
      .sentinel("127.0.0.1", 26579)
      .sentinel("127.0.0.1", 26580);
      return new JedisConnectionFactory(sentinelConfig);
    }
    
    /**
     * Lettuce
     */
    @Bean
    public RedisConnectionFactory lettuceConnectionFactory() {
      RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
      .master("themaster")
      .sentinel("127.0.0.1", 26579)
      .sentinel("127.0.0.1", 26580);
      return new LettuceConnectionFactory(sentinelConfig);
    }

    4.2属性配置

    ProperySource (例如application.properties )可用于配置。 例如,如果我们使用本地主机:

    spring.redis.sentinel.master= themaster # Name of our Redis server.
    spring.redis.sentinel.nodes= localhost:26579, localhost:26580, localhost:26581 # Comma-separated list of host:port pairs.

    5.结论

    今天,我们回顾了如何通过使用Sentinel使用Redis实现高可用性,以及Spring Data Redis如何在Spring应用程序中支持这一点。 有关Sentinel的更多信息, Redis网站是一个很好的来源。

    在我的网站上,还有从Spring Data Redis和Spring Boot开始的信息以及有关Spring Framework的几篇文章。

    翻译自: https://www.javacodegeeks.com/2019/01/spring-data-redis-high-availability-sentinel.html

    redis高并发原理

    展开全文
  • redis高并发原理 在本文中,我们将使用列表命令将Redis用作简单的消息队列。 假设我们有一个允许用户上传照片的应用程序。 然后在应用程序中,我们以不同大小显示照片,例如Thumb,Medium和Large。 在第一个实现中...
    redis高并发原理

    redis高并发原理

    在本文中,我们将使用列表命令将Redis用作简单的消息队列。

    假设我们有一个允许用户上传照片的应用程序。 然后在应用程序中,我们以不同大小显示照片,例如Thumb,Medium和Large。

    在第一个实现中,我们可以承担在同一请求中处理上载图像的任务。 由于这是一项昂贵的任务,因此会使我们的请求变慢。

    一个可能的解决方案是使用消息队列(MQ)使该处理异步进行,有许多众所周知的MQ,例如ActiveMQ,RabbitMQ,IBM MQ等。 在下面的示例中,我们将使用LIST结构将Redis用作消息队列。

    想法是要有一个LIST,生产者将在其中放置要处理的消息,而某些消费者将观看LIST以处理所发送的消息。

    基本上,生产者将使用“ RPUSH队列消息”将消息添加到列表的末尾,而消费者将使用“ LPOP队列”将列表开头的消息配置为FIFO处理。

    客户端将一直在寻找新消息,为此,我们将使用BLPOP命令,该命令是LPOP命令的阻止版本。 基本上会有一个while循环调用BLPOP来处理新消息。

    考虑到图像上传示例,假设我们有一个类ImageUploader负责将图像上传到服务器,它将在队列中添加一条新消息,指示有要处理的图像,消息可能是JSON字符串像这样:

    {“imagePath”:”/path/to/image”, “user”:”userid”}

    ImageUploder类可能是这样的:

    public class ImageUploader {
    
      public void uploadImage(HttpServletRequest request){
    
        String imagePath = saveImage(request);
        String jsonPayload = createJsonPayload(request, imagePath);
        jedis.rpush("queue", jsonPayload);
        //... keep with the processing
      }
    
      //.... other methods in the class
    }

    这只是生产者如何工作的一个例子。 在这种情况下,我们已经将图像处理与ImageUploader类分离了。 我们只是在队列中创建一条新消息,以便消费者处理它们。

    消息使用者可能是这样的:

    package br.com.xicojunior.redistest;
    
    import java.util.List;
    
    import redis.clients.jedis.Jedis;
    
    public class MessageConsumer 
    {
        public static void main( String[] args )
        {
            Jedis jedis = new Jedis("localhost");   
            List<String> messages = null;
            while(true){
              System.out.println("Waiting for a message in the queue");
              messages = jedis.blpop(0,"queue");
              System.out.println("Got the message");
              System.out.println("KEY:" + messages.get(0) + " VALUE:" + messages.get(1));
              String payload = messages.get(1);
              //Do some processing with the payload
              System.out.println("Message received:" + payload);
            }
    
        }
    }

    该使用者代码可以在不同的进程甚至不同的机器上运行。 这个使用者代码是可运行的,我们可以编译它并使用eclipse或java命令运行它。

    对于此代码,我们使用jedis.blpop方法,它返回包含2个字符串的列表,(0)–键,(1)–返回的值。 该方法还接收一个整数,它表示超时。 我们传递了0,表示将没有超时。

    当我们运行此代码并且列表中没有值时,在控制台中,我们将仅看到消息

    "Waiting for a message in the queue".

    然后,如果客户在“队列”列表中添加元素,我们的消费者类将获得其价值。 我们可以使用redis-cli或另一个将在队列中添加元素的类来模拟测试,如下所示:

    package br.com.xicojunior.redistest;
    
    import redis.clients.jedis.Jedis;
    
    public class MessageProducer {
    
      public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
    
        jedis.rpush("queue", "Value 1");
        jedis.rpush("queue", "Value 2");
        jedis.rpush("queue", "Value 3");
    
      }
    
    }

    如果我们在MessageConsumer类已经运行之后运行MessageProducer类,我们将在控制台中看到以下输出:

    Waiting for a message in the queue
    Got the message
    KEY:queue VALUE:Value 1
    Message received:Value 1
    Waiting for a message in the queue
    Got the message
    KEY:queue VALUE:Value 2
    Message received:Value 2
    Waiting for a message in the queue
    Got the message
    KEY:queue VALUE:Value 3
    Message received:Value 3
    Waiting for a message in the queue

    因此,消息队列将是Redis的另一个可能的用例。 在redis之上建立了一些队列,如RestMQResque – Job Queue等。

    参考: XICO JUNIOR'S WEBLOG博客中来自JCG合作伙伴Francisco Ribeiro Junior的使用Redis的简单消息队列

    翻译自: https://www.javacodegeeks.com/2014/01/simple-message-queue-using-redis.html

    redis高并发原理

    展开全文
  • redis高并发原理 在以前的文章中,我们回顾了在不同线程之间共享数据的一些主要风险(例如原子性和可见性)以及如何设计类以安全共享(线程安全设计)。 但是,在许多情况下,我们将需要共享可变数据,其中一些线程将...
  • 解析Redis 高并发原理

    2020-10-27 15:20:30
    但是可以确定的是不会有两条命令被同时执行,不会产生并发问题,这就是Redis的单线程基本模型。 2 单线程模型每秒万级别处理能力的原因 (1)纯内存访问。数据存放在内存中,内存的响应时间大约是100纳秒,这是Redis...
  • redis高并发原理 Apache Hadoop,Apache Spark,Akka,Java 8流和Quasar:针对Java开发人员的经典用例以及最新的并发方法 关于并发性更新概念的讨论很多,但是许多开发人员还没有机会将他们的想法缠住。 在本文中...
  • Where to find complete Redis documentation? ------------------------------------------- This README is just a fast "quick start" document. You can find more detailed documentation at http://redis.io ...
  • redis高并发原理 显然,编写URL缩短服务是新的“世界,您好! ”在物联网/微服务/时代的世界中。 一切始于在45行Scala中的URL缩短服务-整洁的Scala,以Spray和Redis进行调味以进行存储。 随后,在35行Clojure中使用...
  • 如何保证 redis高并发和高可用?redis 的主从复制原理能介绍一下么?redis 的哨兵原理能介绍一下么? 面试官心理分析 其实问这个问题,主要是考考你,redis 单机能承载多高并发?如果单机扛不住如何扩容扛更多...
  • 如何保证 Redis 高并发、高可用?Redis 的主从复制原理能介绍一下么?Redis 的哨兵原理能介绍一下么?   面试题 如何保证 redis高并发和高可用?redis 的主从复制原理能介绍一下么?redis 的哨兵原理能介绍...
  • Redis高并发和高可用

    2021-01-01 19:58:07
    如何保证 redis高并发和高可用?redis 的主从复制原理能介绍一下么?redis 的哨兵原理能介绍一下么?其实问这个问题,主要是考考你,redis 单机能承载多高并发?如果单机扛不住如何扩容扛更多的并发?redis 会...
  • redis实现高并发机制的原理redis运行原理图解
  • Redis高并发点赞

    2020-06-03 20:15:12
    1、redis高并发点赞就是保护数据库进行的操作 原理:就是将点赞数和点赞用户先存入redis中(防止大量用户数据对数据库的操作),通过定时任务在将数据取出来。 操作: 1、先将前端的数据存入redis中 源代码: /** ...
  • 关于redis高并发你晓得多少?1、redis高并发跟整个系统的高并发之间的关系2、redis不能支撑高并发的瓶颈在哪里?3、如果redis要支撑超过10万+的并发,那应该怎么做?4、接下来要讲解的一个topic5、redis replication...
  •  如何保证Redis高并发和高可用?redis的主从复制原理能介绍一下么?redis的哨兵原理能介绍一下么?  2 考点分析  其实问这个问题,主要是考考你,redis单机能承载多高并发?  如果单机扛不住如何扩容抗更多的...
  • 如何保证 redis高并发和高可用?redis 的主从复制原理能介绍一下么?redis 的哨兵原理能介绍一下么? 面试官心理分析 其实问这个问题,主要是考考你,redis 单机能承载多高并发?如果单机扛不住如何扩容扛更多...
  • 机械工业出版社出版,尼恩编著的《Netty Zookeeper Redis 高并发实战》一书, 从操作系统底层的IO原理入手,同时提供高性能开发的实战案例,是一本高并发Java编程应用基础图书。 本书共分为12章。 第1~5章为高并发...
  • 如何保证 redis高并发和高可用?redis 的主从复制原理能介绍一下么?redis 的哨兵原理能介绍一下么? 面试官心理分析 其实问这个问题,主要是考考你,redis 单机能承载多高并发?如果单机扛不住如何扩容扛更多...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 868
精华内容 347
关键字:

redis高并发原理

redis 订阅