大话Redis系列--深入探讨多路复用（上）

最新推荐文章于 2024-10-17 22:56:22 发布
最新推荐文章于 2024-10-17 22:56:22 发布
阅读量354 收藏
点赞数
分类专栏： nosql 数据库 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/danny_idea/article/details/120033422
版权

今天让我们一起来探讨一下多路复用在redis中的具体实现原理。

Redis客户端和服务端的连接访问介绍

之前的文章中我们有稍微提到过，Redis的客户端和服务端之间是通过resp协议进行链接通信的。这种通信的本质其实是借助了socket套接字进行网络连接。如下图所示：

在这里插入图片描述

当客户端的jedis和redis服务器进行连接的时候，首先需要在对应操作系统的内核中建立连接，接着才会将对应的链接分配到指定的redis服务端程序当中。假设redis采用了默认的6379端口，那么对应的链接请求就会发送到对应的进程上。

如何理解多路复用
当请求处理完毕之后，这一整条的链接链路不会立马断开，而为维持长链接的状态，方便后续继续传输数据使用。
为了方便大家对于多路复用能有个更好的认识，我们接下来通过一段Java程序来认识多路复用的实际应用案例。

Java模拟实现服务端链接
这是一段非常简单的BIO程序，大概思路便是接纳外界链接请求，然后打印数据到控制台。


package org.idea.iedis.framework.server.io.core;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Author linhao
 * @Date created in 11:16 上午 2021/8/15
 */
public class BioServer {

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(6378);
        while (true) {
            System.out.println("wait conn --------");
            Socket socket = serverSocket.accept();
            System.out.println("conn ok ---------");
            byte[] bytes = new byte[1024];
            System.out.println("wait data ---------");
            socket.getInputStream().read(bytes);
            System.out.printf("data is {}" + new String(bytes));
        }
    }
}

测试的方式我采用了nc命令进行模拟：

【idea @ Mac】>>>>>>nc localhost 6378
a

当请求到达服务端的时候，也会在控制台有所打印输出：
在这里插入图片描述

上边代码的哪些点是堵塞的位置？

serverSocket.accept(); //堵塞部分
socket.getInputStream().read(bytes); //堵塞部分

我们通过实操可以发现，在accept的位置会出现第一次堵塞的情况，当没有外界连接接入的时候，程序就会堵塞在该位置。
第二次堵塞的位置是在read函数调用的位置，当连接建立之后，服务端会一直等待客户端发送的数据请求，因此一直处于等待状况。

如果第一个连接建立之后迟迟不发送数据，后续又有第二个连接接入会出现什么问题？
为了模拟这个场景，我们来看下以下测试案例：

首先是服务端程序的部分改造，对于客户端的请求，我这里新增了一个handleData函数，用于模拟处理数据时候的堵塞情况（耗时大约为2秒左右）

package org.idea.iedis.framework.server.io.core;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Author linhao
 * @Date created in 11:16 上午 2021/8/15
 */
public class BioServer {

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(6378);
        while (true) {
            System.out.println("wait conn --------");
            Socket socket = serverSocket.accept();
            System.out.println("conn ok --------- " + System.currentTimeMillis());
            byte[] bytes = new byte[1024];
            System.out.println("wait data ---------");
            socket.getInputStream().read(bytes);
            handleData();
            System.out.printf("data is {}" + new String(bytes));
        }
    }

    /**
     * 处理数据信息
     */
    public static void handleData(){
        System.out.println("handling data begin ----------");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("handling data end ----------");
    }
}

接着便是客户端部分的模拟，模拟五个客户端的连接服务端，并且发送数据：

package org.idea.iedis.framework.server.io.core;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author linhao
 * @Date created in 11:17 上午 2021/8/15
 */
public class BioClient {

    public static final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 5,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>());

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    Socket socket = new Socket();
                    try {
                        socket.connect(new InetSocketAddress("localhost", 6378));
                        socket.getOutputStream().write("this is test".getBytes());
                        System.out.println("send data -----------" + System.currentTimeMillis());
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            threadPoolExecutor.submit(t);
        }
        Thread.yield();
    }
}

通过请求的日志记录可以发现，服务端对于数据的处理时间点如下：
在这里插入图片描述

也就是说当上一个连接在处理请求的时候，下一个连接发送的数据会处于一个就绪状态，单线程依次执行。

多线程异步等待模型改造

将服务端处理线程请求的模块开启单独的线程进行处理。
服务端程序进行改造：

package org.idea.iedis.framework.server.io.core;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Author linhao
 * @Date created in 11:16 上午 2021/8/15
 */
public class BioServer {

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(6378);
        while (true) {
            System.out.println("wait conn --------");
            Socket socket = serverSocket.accept();
            System.out.println("conn ok --------- " + System.currentTimeMillis());
            byte[] bytes = new byte[1024];
            System.out.println("wait data ---------");
            socket.getInputStream().read(bytes);
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    handleData();
                }
            });
            t.start();
            System.out.printf("data is {}" + new String(bytes));
        }
    }

    /**
     * 处理数据信息
     */
    public static void handleData(){
        System.out.println("handling data begin ----------");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("handling data end ----------");
    }
}

此时控制台打印出来的结果如下所示：
在这里插入图片描述

看起来似乎是请求处理的效率变高了，但是实际上这种方案对于性能的开销是比较大的。
假设我们同时有1000个请求发送过来，那么服务端就得启动1000个线程处理。
假设建立了1000个连接，但是其中只有10条连接发送了数据，那么这个开销从利用率来说更加不划算。
其实在tomcat7之前，其服务端的程序一直都是采用bio的模式来进行处理请求数据，每次发送请求之后都需要额外创建一个线程处理数据，因此其并发处理能力并不友好。

改善思路

  • 当没有建立服务端连接的时候，accept函数调用的时候不要出现阻塞，而是直接跳过。
  • 在没有数据抵达服务端的时候，read函数调用采用非阻塞的方式执行。

有了这两个思路点之后，我们再来深入思考：

假设我们是jdk的开发者，需要对现有的代码做怎样的调整？

这里分享一下我自己的思路：
首先ServerSocket是一个已经存在于JDK内部的对象，而且不建议随意对已有的api进行调整，否则会对业界使用者造成一个不兼容的情况。
因此不妨可以通过一些setter方法去修改阻塞的设置项：

在这里插入图片描述

来看看实际JDK开发者是如何改良这部分设计的：
首先是使用nio搭建一个简单的服务端代码案例：

package org.idea.iedis.framework.server.io.core.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author linhao
 * @Date created in 8:41 上午 2021/8/16
 */
public class NioServer {

    static ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    static List<SocketChannel> channelList = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        SocketAddress socketAddress = new InetSocketAddress("localhost", 6666);
        serverSocketChannel.bind(socketAddress);
        serverSocketChannel.configureBlocking(false);

        //有点类似于poll模型
        while (true) {
            for (SocketChannel socketChannel : channelList) {
                int read = socketChannel.read(byteBuffer);
                if (read > 0) {
                    System.out.println("read ... " + read);
                    byteBuffer.flip();
                    byte[] bs = new byte[read];
                    byteBuffer.get(bs);
                    String content = new String(bs);
                    System.out.println(content);
                    byteBuffer.flip();
                }
            }

            SocketChannel accept = serverSocketChannel.accept();
            if (accept != null) {
                System.out.println("conn success -----");
                accept.configureBlocking(false);
                channelList.add(accept);
                System.out.println(channelList.size() + "---- list --- size");
            }
        }
    }
}

接着是基于这套服务端代码去编写相关的客户端程序脚本：

package org.idea.iedis.framework.server.io.core.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

/**
 * @Author linhao
 * @Date created in 8:40 上午 2021/8/16
 */
public class NioClient {


    public static void main(String[] args) throws IOException, InterruptedException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost", 6666));
        socketChannel.configureBlocking(false);
        socketChannel.write(ByteBuffer.wrap("this is a test".getBytes()));
        System.out.println("-----");
    }

}

上边的这段代码总体的执行思路其实可以抽像化为以下模式：（假设有三个链接请求）

select (3 sockets){
for(Socket socket: sockets) {
int read = socket.getInputStream();    
 if(read >0){  
     // 对应处理代码   
       } else {  
    // 对应处理代码  
       }  
  }
}

但是这样的代码我们在进行实际落地实现的时候不可能采用Java程序去实现，通常都是在os底层来进行封装，然后供高级语言去调用。

思考：
假设构建了100w条链接，那么对于这一批的链接采用暴力的list遍历方式去询问是否有新数据的写入就会显得效率异常低下。

改善点：
假设当我们建立好了链接请求之后，每个链接都会订阅某个事件，假设是有数据写入的时候，主动去发布这个事件，这样就能避免轮训操作了。

NIO内部如何解决多路复用机制

从这个角度思考出发，我们一起来看下nio内部是如何实现多路复用机制的，
当有新的请求过来的时候，server会提前将accept事件委托给selector处理。
selector会根据连接的事件类型（例如read，write，accept）去通知到具体的socketserver。

来看看案例代码：
服务端新增一个selector代码

package org.idea.iedis.framework.server.io.core.nio.selector;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;

/**
 * @Author linhao
 * @Date created in 8:27 上午 2021/8/17
 */
public class NioSelectorServer {

    static ArrayList<SocketChannel> socketChannels = new ArrayList<>();
    static ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        SocketAddress socketAddress = new InetSocketAddress("localhost", 6555);
        serverSocket.configureBlocking(false);
        serverSocket.bind(socketAddress);

        Selector selector = Selector.open();

        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("start select!");
        while (true) {
            selector.select();
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                if (selectionKey.isAcceptable()) {

                    SocketChannel socketChannel = serverSocket.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("client is connected!");

                } else if (selectionKey.isReadable()) {

                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int len = socketChannel.read(byteBuffer);

                    if (len > 0) {
                        System.out.println("receive data!" + new String(byteBuffer.array(),0,len));
                    } else if (len == -1) {
                        System.out.println("client is close");
                        socketChannel.close();
                    }
                }
                iterator.remove();
            }
        }
    }

}

客户端向服务端发送数据的案例代码：

package org.idea.iedis.framework.server.io.core.nio.selector;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

/**
 * @Author linhao
 * @Date created in 8:53 上午 2021/8/17
 */
public class NioSelectorClient {

    public static void main(String[] args) throws IOException, InterruptedException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost",6555));
        socketChannel.configureBlocking(false);
        while (true) {
            System.out.println("client send data");
            socketChannel.write(ByteBuffer.wrap(("this is success " + Thread.currentThread().getName()).getBytes()));
            Thread.sleep(2500);
        }
    }
}

从上边服务端的程序案例可以看出，首先获取到链接之后，会将一个接收事件（accept）给注册到一个叫做selector的组件上。接下来后续这个链接如果有发送请求到数据过来就会被识别是read事件，此时selector再会去通知具体到服务线程处理。大概到思路如下图所示：

在这里插入图片描述

思考
selector在进行select的时候，会发生什么情况？
如果外界没有额外请求进入的话，那么select函数会进入一个堵塞等待的状态。看起来效果有些类似于bio的accept函数。

selector调用open函数，它会发生了什么变化？

我们对selector的open函数源代码进行深入挖掘，可以发现具体如下所示：
在这里插入图片描述

在其源代码的底部调用了JDK内部的sun.nio.ch.DefaultSelectorProvider.create()函数。这个函数的代码底层实际上会调用到jdk内部的一些函数，再由jdk内部去调用一些native方法，最终会调用到os中的接口，假设该程序所运作的os环境是linux操作系统，那么最底层就会调用到epool相关的三个函数。
epoll_create,epoll_ctl,epoll_wait。

Redis底层源代码中是如何实现多路复用的

这里我打开的是redis6.0的源代码进行阅读：
文件名称：ae_epoll.c
ps：由于自己对于C源代码并不是特别熟悉，所以这里只能简单说下
下边的这张截图中体现了使用epoll_create函数取创建一个链接。
在这里插入图片描述

这段代码则是使用了epollo_ctl函数来处理一些事件的注册处理。
在这里插入图片描述

下边的epoll_wait看起来则像是监听某些兴趣事件。
在这里插入图片描述

由于文章篇幅有限，后边会接着出一篇文章继续深入研究下多路复用的内容。

Danny_idea
关注
专栏目录
〖Python 数据库开发实战 - Python与Redis交互篇①〗- redis-py的安装与使用
易编橙 · 终身成长社群，相遇已是上上签！
09-22 4万+
该章节开始我们又回到了 Python 领域，接下来我们将学习利用 Python 语言去读写 redis 的数据。之前操作 redis ，是在客户端通过一些指令来实现的，在 Python 中操作 redis 的依然还是这些指令，所以掌握了 redis 的命令与数据类型， Python 的程序就很好写了。在 Python 中操作 redis 的第三方模块有很多，这里推荐使用 redis-py 这个模块，不仅是因为它很容易使用，更因为它自带连接池。接下来就正式的进入学习环节吧。
Redis 6 redis-cluster-proxy 集群代理使用
yangyun901222的博客
10-16 2114
redis-cluster-proxy
Redis底层多路复用
pengxiaozhang的博客
05-05 2601
Redis6：第十五篇-多路复用相关问题Redis的多路复用什么是IO多路复用文本事件同步异步阻塞非阻塞同步异步阻塞非阻塞 本篇文章是来复习Redis的多路复用以及相关知识 Redis的多路复用 什么是IO多路复用 Redis利用epoll来实现IO多路复用，将连接信息和事件放到队列中，一次性放到文本事件分派器，事件分派器把事件分给事件处理器 在上图中：用户有三个socket连接，一个是建立连接的socket server，一个设置key的连接，一个是获取key的连接，这三个连接去请求Redis，会先请求
Redis 多路复用
旷野历程
12-23 4248
Redis 多路复用
【Redis】IO多路复用机制
日拱一卒，不期速成！
05-15 4407
IO多路复用机制
【redis学习】Redis-IO多路复用
weixin_47537043的博客
05-08 2730
网络IO在系统层面上指的是数据从用户态到内核态的读写操作，多路是指多个socket连接。在UNIX网络编程中写道为了执行网络IO，一个进程必须要做的第一件事就是调用socket函数。复用是指一个或多个连接处理。一个服务端进程可以同时处理多个套接字描述符。redis使用IO多路复用简单来说就是，单线程处理多个客户端连接的网络读写请求，并且能够保证不会阻塞主流程的一种机制。实现IO多路复用的模型有3种：可以分select->poll->epoll三个阶段来描述。
redis IO多路复用机制
最新发布
水w的博客
10-17 1005
redis IO多路复用机制
redis-cluster-proxy:Redis集群的代理
05-04
Redis群集代理是多线程的，并且当前默认情况下使用多路复用通信模型，因此每个线程都具有自己的与群集的连接，该连接由属于该线程本身的所有客户端共享。 无论如何，在某些特殊情况下（例如MULTI事务或阻止命令），...
Nginx+Redis 利用redis2-nginx-module让Nginx直接访问Redis服务
licaomeng的专栏
04-02 1万+
Nginx常用作反向代理服务器，而Redis是一种key-value数据库。本文将叙述如何让Nginx直接访问Redis服务。需要用到Nginx模块redis2-nginx-module。GitHub地址：https://github.com/openresty/redis2-nginx-moduleGitHub上的README讲解的还是比较清楚。但是该模块的目的并不像我们标题所说的这么单纯，所以...
Redis的多路复用机制
qq_46130027的博客
07-23 432
当我们客户端向他注册事件的时候，调的就是这个接口。注册进来之后，假如我发了数据过来，触发了一个IO事件，那么这个时候selector会返回翻一个事件的数组，一个集合两个events，然后由我们的redis把这两个events的数据拿到之后进行处理。这些在Linux操作系统里提供了相应的函数，比方说我们要创建一个收集器或者叫多路复用神器，我们会去调用操作系统的epoll_create这个函数，来声明一个事件收集器的一个内存空间，专门用来存很多事件的，来感知有没有事件发生调epoll_create。
网络模型-IO多路复用
admin3335的博客
10-19 738
网络模型-IO多路复用
Redis高性能设计之epoll和IO多路复用深度解析
qq_43456605的博客
03-15 1539
在处理多个客户端连接redis问题时，在多路复用没有出来之前，通常的解决方案就是同步阻塞网络IO（BIO）。这个模式的特点就是用一个进程来处理一个网络请求（一个用户请求）。这种思路很简单易懂，但是却存在着很大的问题，它的性能时极差的，如果每个用户请求都开辟一个新的进程来处理，那么来一个请求就需要分配一个进程来进行处理，如果来了海量的用户系统根本创建不了这么多线程来处理用户请求。必须让一个进程能够同时处理很多TCP连接。
什么是Redis的多路复用？
让~学习~成为一种习惯（橡 皮 人の技术博客）
04-07 577
具体实现方式是Redis采用了select、poll、epoll等系统调用来实现多路复用I/O，Redis会将所有需要监听的socket（包括客户端和服务器端）加入到一个事件集合中，并使用select、poll、epoll等系统调用等待这些socket上是否有I/O事件发生，当有I/O事件发生时，Redis会通过事件处理器将该事件分发到对应的处理器进行处理。在这个过程中，Redis维护了一个事件处理器，它包含了多个事件的处理器，每个事件处理器都是一个函数指针，用于处理特定的事件类型。那么它有什么特别的呢？
redis的多路复用
qq_40058686的博客
03-26 918
redis是一个单进程单线程的内存数据库，主要用来作为缓存系统。采用了网络io多路复用技术来保证在多连接的时候的系统的吞吐量 为什么redis使用io多路复用技术？ 因为redis是单线程的，所有的操作都是按照顺序线性执行的，但是由于读写操作是阻塞的，所以某个请求假如是阻塞的话那么整个进程都无法对其他客户端提供服务。所以就有了io多路复用 redis的io多路复用模型是基于e...
Redis I/O 多路复用
热门推荐
diweikang的博客
05-19 2万+
引出IO多路复用 为什么 Redis 中要使用 I/O 多路复用这种技术呢？ 首先，Redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以 I/O 操作在一般情况下往往不能直接返回，这会导致某一文件的 I/O 阻塞导致整个进程无法对其它客户提供服务，而 I/O 多路复用就是为了解决这个问题而出现的。 要弄清问题先要知道问题的出...
Redis多路复用，线程
xuan__xia的博客
06-10 173
用 select、poll、epoll 可以同时监察多个流的 I/O 事件的能力，在空闲的时候，会把当前线程阻塞掉，当有一个或多个流有 I/O 事件时，就从阻塞态中唤醒，然后程序就会轮询一遍所有的流（epoll 是只轮询那些真正发出了事件的流），并且依次顺序的处理就绪的流，这种做法就避免了大量的无用操作。但是在Redis6.0之后，执行这三个操作可以是多线程，如线程1执行readIO，线程2执行计算，线程1再执行writeIO。因此需要多路复用，只有当有IO流（客户端发送命令的时候）才会去轮询。
Redis网络模型、IO多路复用
weixin_38915773的博客
06-12 657
Redis网络模型、IO多路复用、Redis性能分析、高性能
谈谈Redis中的多路复用
一个菜鸡的博客
11-21 464
redis是单线程的（不严谨的讲法的哈），为什么还这么快，很多人相信会回答因为redis是基于内存操作的, 内存的读写速度是非常快的。答到这，逼格还是不够高的，基于内存是一方面，但还有一个关键点是：redis采用了多路复用技术，今天我们就来聊聊这个点。​多路：多个客户端连接复用：使用单进程就能够实现同时处理多个客户端的连接 ​它的基本原理就是不再由应用程序自己监视连接，而是由内核替应用程序监视文件描述符。客户端在操作的时候，会产生具有不同事件类型的 socket。
Redis演进与Redis-Cluster集群读写策略
本文深入探讨了从基本的主从架构到哨兵模式，再到Redis-cluster的演进，同时介绍了Java客户端Jedis和Lettuce在处理Redis-cluster数据读写上的应用。" Redis架构的演变主要经历了以下几个阶段： 1. **Redis普通主从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值