Redis高性能设计之epoll和IO多路复用深度解析

最新推荐文章于 2024-07-22 08:39:34 发布
最新推荐文章于 2024-07-22 08:39:34 发布
阅读量1.4k 收藏 26
点赞数 22
分类专栏： Redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43456605/article/details/136677493
版权

文章目录

一、简介

1. 背景

在处理多个客户端连接redis问题时，在多路复用没有出来之前，通常的解决方案就是同步阻塞网络IO（BIO）。这个模式的特点就是用一个进程来处理一个网络请求（一个用户请求）。这种思路很简单易懂，但是却存在着很大的问题，它的性能时极差的，如果每个用户请求都开辟一个新的进程来处理，那么来一个请求就需要分配一个进程来进行处理，如果来了海量的用户系统根本创建不了这么多线程来处理用户请求。在Linux中，创建一个进程的开销时非常大的，所以为了应对海量用户的请求，我们必须实现这个条件：必须让一个进程能够同时处理很多TCP连接，现在问题又来了，如果一个进程上保持了10000条连接，那么如何发现哪条连接上有数据可读，哪条连接上需要写数据呢？

当然我们可以使用轮询的方式来遍历所有连接，但是这种方式效率是很低的

为了满足上面的需求，IO多路复用技术就出现了，注意复用是指对进程的复用。

2. IO多路复用介绍

IO：网络I/O

多路：多个库护端连接（连接就是套接字描述符，即socket或者channel），指的是多条TCP连接

复用：用一个进程来处理多条连接，使用单进程就可以实现同时处理多个客户端连接

IO多路复用实现了一个进程来处理大量的用户连接。

IO多路复用linux系统已经实现好了：select—>poll—>epoll三个阶段来描述

二、I/O多路复用Redis中的应用

1. 问题分析

redis单线程是如何处理那么多并发客户端连接的，而且还这么快？

Redis利用epoll来实现IO多路复用，将连接信息和时间放在队列中，依次放到文件事件分派其，时间分派器将事件分发给事件处理器。

在这里插入图片描述

Redis是跑在单线程当中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以I/O操作在一般情况下往往不能直接返回，这就导致某一文件的I/O阻塞导致整个进程无法对其它客户提供服务，而I/O多路复用为了解决这个问题而出现。

所谓I/O多路复用机制，就是说通过一种机制，可以监视多个描述符。一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知主程序进行相应的读写操作，这种机制需要select或poll或epoll来配合。多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接，当某条连接有新的数据需要处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。

Redis服务采用Reactor的方式来实现文件事件处理（每一个网络都对应一个文件描述符），Redis基于Reactor模式开发了网络事件处理器，这个处理器也称为文件处理器，它的组成结构为4部分：

  • 多个连接套接字
  • 文件事件分派器
  • 事件处理器

因为文件事件分派器队列的消费时单线程的，所以Redis才叫单线程模型

从redis 6开始，将网络数据读写、请求协议解析通过多个IO线程来处理，对于真正执行redis命令，则还是当线程的。

在这里插入图片描述

2. Unix网络编程中的五种IO模型

Unix有下面五种IO模型：

  • Blocking IO：阻塞IO
  • NoneBlockingIO：非阻塞IO
  • IO multiplexing：IO多路复用
  • signal driven IO：信号驱动IO
  • asynchronous IO：异步IO

同步：同步是指在发起一个操作后，必须等待该操作完成后才能继续执行后续的操作。在同步操作中，调用者会阻塞（暂停）直到被调用的函数或任务完成并返回结果。

异步：异步是指发起一个操作后，不需要等待该操作完成，可以立即执行后续的操作。在异步操作中，调用者不会阻塞，而是继续执行其他任务。被调用的任务在后台执行，执行完后通常通过回调函数或者其他机制来通知调用者。

阻塞：阻塞是指调用者在执行一个操作时，如果该操作无法立即完成，调用者会一直等待直到操作完成或者超时。在阻塞模式下，调用者线程或进程会被挂起，直到等待的事件发生。

非阻塞：非阻塞是指调用者在执行一个操作时，如果该操作无法立即完成，调用者会立即返回并继续执行其他任务，而不是等待操作完成。在非阻塞模式下，调用者会周期性地检查等待的事件是否发生，而不是被挂起等待。

同步和异步主要关注的是任务的调度方式。同步指任务顺序执行，而异步指任务可以在后台独立执行。阻塞和非阻塞主要关注的是等待调用结果时的行为。阻塞表示调用者会等待结果返回，而非阻塞表示调用者不会等待结果返回，可以继续执行其他任务。

同步阻塞：调用者发起一个操作后，必须等待操作完成，期间调用者会被阻塞，无法执行其他任务。直到操作完成并返回结果后，调用者才能继续执行后续的操作。

同步非阻塞：调用者发起一个操作后，仍然需要等待操作完成，但在等待的过程中，调用者可以执行其他任务，而不会被阻塞。通常这种情况下会使用轮询或者多线程等机制来实现

异步阻塞：调用者发起一个异步操作后，立即返回并继续执行其他任务。但在等待异步操作完成的过程中，调用者会被阻塞，无法执行其他操作。异步操作完成后，调用者才能获取到结果。

异步非阻塞：调用者发起一个异步操作后，立即返回并继续执行其他任务。在等待异步操作完成的过程中，调用者不会被阻塞，可以继续执行其他操作。通常通过回调函数或事件通知的方式来处理异步操作的完成。

3. Unix网络编程中的IO模型java验证

  • BIO

在这里插入图片描述

recvfrom函数时Linux底层用于从已连接的套接字上接受数据，并捕获数据发生源的地址

当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据（对于网络IO来说，很多时候数据在一开始还没有到达）。这个过程需要等待，也就是说数据被拷贝到操作系统内核的缓存区种是需要一个过程的，而在用户进程这边，整个进程会被阻塞（当然是用户进程自己选择的阻塞）。当kernel一直等待数据准备好了，它就会将数据从kernel种拷贝到用户内存，然后kernel返回结果，用户进程才解除block状态，重新运行起来，所以BIO的特点就是在IO执行的两个阶段都被Block了。

public class RedisClient01 {
    public static void main(String[] args) throws IOException {
        System.out.println("start......");
        Socket socket=new Socket("127.0.0.1",8888);
        System.out.println("stop.......");
    }
}


public class RedisServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket=new ServerSocket(8888);
        while(true){
            System.out.println("服务器启动......");
            Socket socket=serverSocket.accept();
            System.out.println("连接成功.....");
        }
    }
}

上面代码RedisServer一直在等待客户端连接，所以服务端一直在被阻塞。

public class RedisClient01 {
    public static void main(String[] args) throws IOException {
        System.out.println("start......");
        Socket socket=new Socket("127.0.0.1",8888);
        OutputStream outputStream=socket.getOutputStream();
        while(true){
            Scanner scanner=new Scanner(System.in);
            String string=scanner.next();
            if(string.equalsIgnoreCase("quit")){
                break;
            }
            socket.getOutputStream().write(string.getBytes());
            System.out.println("RedisClient01 input quit keyword to finish.....");
        }
        outputStream.close();
        System.out.println("stop.......");
    }
}

public class RedisClient02 {
    public static void main(String[] args) throws IOException {
        System.out.println("start......");
        Socket socket=new Socket("127.0.0.1",8889);
        OutputStream outputStream=socket.getOutputStream();
        while(true){
            Scanner scanner=new Scanner(System.in);
            String string=scanner.next();
            if(string.equalsIgnoreCase("quit")){
                break;
            }
            socket.getOutputStream().write(string.getBytes());
            System.out.println("RedisClient01 input quit keyword to finish.....");
        }
        outputStream.close();
        System.out.println("stop.......");
    }
}

public class RedisServerBIO {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket=new ServerSocket(8888);
        while(true){
            System.out.println("等待连接.....");
            Socket socket=serverSocket.accept();
            InputStream inputStream=socket.getInputStream();
            int length=-1;
            byte[] bytes=new byte[1024];
            while((length=inputStream.read(bytes))!=-1){
                System.out.println("成功读取......"+new String(bytes,0,length));
                System.out.println();
            }
            inputStream.close();
            socket.close();
        }
        
    }
}

RedisServerBIO启动，然后启动RedisClient01，现在RedisClient01可以和RedisServerBIO通信，前者发送的信息server都可以收到，现在启动RedisClient02，然后向server发送3条消息，发现server并没有回复，然后RedisClient01退出，发现询价收到了之前RedisClient02发送的所有消息。这个案例我们就可以看出BIO的问题：

如果客户端连接了服务端，但是客户端迟迟不发送数据，此时服务端会一直阻塞在该客户端（read()）方法，这样其它客户端永远得不到响应，也就是一次只能处理一个客户端，这样对客户会非常不友好。

下面利用多线程模型对上面案例进行改进，只要连接了一个socket，操作系统就分配一个线程来处理，这样read方法阻塞在每个具体线程上而不阻塞主线程。

public class RedisClient01 {
    public static void main(String[] args) throws IOException {
        System.out.println("start......");
        Socket socket=new Socket("127.0.0.1",8889);
        OutputStream outputStream=socket.getOutputStream();
        while(true){
            Scanner scanner=new Scanner(System.in);
            String string=scanner.next();
            if(string.equalsIgnoreCase("quit")){
                break;
            }
            socket.getOutputStream().write(string.getBytes());
            System.out.println("RedisClient01 input quit keyword to finish.....");
        }
        outputStream.close();
        System.out.println("stop.......");
    }
}

public class RedisClient02 {
    public static void main(String[] args) throws IOException {
        System.out.println("start......");
        Socket socket=new Socket("127.0.0.1",8889);
        OutputStream outputStream=socket.getOutputStream();
        while(true){
            Scanner scanner=new Scanner(System.in);
            String string=scanner.next();
            if(string.equalsIgnoreCase("quit")){
                break;
            }
            socket.getOutputStream().write(string.getBytes());
            System.out.println("RedisClient01 input quit keyword to finish.....");
        }
        outputStream.close();
        System.out.println("stop.......");
    }
}

public class RedisServerBIO {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket=new ServerSocket(8889);
        while(true){
            System.out.println("等待连接.....");
            Socket socket=serverSocket.accept();
            System.out.println("连接成功.....");
            new Thread(()->{
                try (InputStream inputStream=socket.getInputStream()){
                    int length=-1;
                    byte[] bytes=new byte[1024];
                    while((length=inputStream.read(bytes))!=-1){
                        System.out.println("成功读取......"+new String(bytes,0,length));
                        System.out.println();
                    }
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            },Thread.currentThread().getName()).start();
        }

    }
}

这样一来RedisClient01和RedisClient02的请求都得到了处理，解决了上面方案的问题。但是多线程这种方法，对于海量用户请求就不太合适了，在操作系统中用户态不能直接开辟线程，需要调用内核来创建一个线程，这其中还涉及到用户态的切换，十分耗费资源。改进方法：

  • 线程池：但是用户量大的时候，我们并不知道线程池要多大，太大了内存可能不够，所以这种方案可能也不太行
  • NIO：非阻塞IO，因为read()方法阻塞了，所以来开辟多个线程，如果上什么方法能使read()方法不再阻塞，这样就不用开辟多个线程了，这就用到了NIO。
  • NIO

前面我们分析到BIO的缺点就是每个线程分配一个连接，必然会产生多个，既然是多个Socket连接必然需要统一放入容器，纳入统一管理

当用户进程发起read操作的时候，如果kernel的数据还没有准备好，那么它并不会阻塞用户进程，而是立刻返回一个error，从用户进程角度讲，它发起一个read操作后，并不需要等待，而是马上就得到一个结果。。用户进程判断结果是一个error是，它就知道数据还没有准备好，于是它可以再次发送read操作。移动kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就把数据拷贝到用户内存，然后返回，所以NIO的特点就是用户进程需要不断的主动循环内核数据准备好了吗，一句话用轮询代替阻塞。

在这里插入图片描述

在NIO模式中，一切都是非阻塞的：

  1. accept()方法是非阻塞的，如果没有客户端连接，就返回无连接标识
  2. read()方法是非阻塞的，如果read()方法读取不到数据就返回空闲中标识，如果读取到数据时只阻塞read()方法读数据的时间

在NIO模式中，只有一个线程：当客户端与服务端进行连接，这个socket就会加入一个数组中，隔一段时间遍历一次，看这个socket和read方法是否能读到数据，这样一个线程就能处理多个客户端连接了。

public class RedisClient01 {
    public static void main(String[] args) throws IOException {
        System.out.println("start......");
        Socket socket=new Socket("127.0.0.1",8889);
        OutputStream outputStream=socket.getOutputStream();
        while(true){
            Scanner scanner=new Scanner(System.in);
            String string=scanner.next();
            if(string.equalsIgnoreCase("quit")){
                break;
            }
            socket.getOutputStream().write(string.getBytes());
            System.out.println("RedisClient01 input quit keyword to finish.....");
        }
        outputStream.close();
        System.out.println("stop.......");
    }
}

public class RedisClient02 {
    public static void main(String[] args) throws IOException {
        System.out.println("start......");
        Socket socket=new Socket("127.0.0.1",8889);
        OutputStream outputStream=socket.getOutputStream();
        while(true){
            Scanner scanner=new Scanner(System.in);
            String string=scanner.next();
            if(string.equalsIgnoreCase("quit")){
                break;
            }
            socket.getOutputStream().write(string.getBytes());
            System.out.println("RedisClient01 input quit keyword to finish.....");
        }
        outputStream.close();
        System.out.println("stop.......");
    }
}

public class RedisServerNIO {
    static ArrayList<SocketChannel> socklist = new ArrayList<>();
    static ByteBuffer byteBuffer = ByteBuffer.allocate(2023);

    public static void main(String[] args) throws IOException {
        System.out.println("RedisSServerNiO启动中.......");
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress("127.0.0.1", 8889));
        serverSocket.configureBlocking(false);  //设置为非阻塞模式
        while (true) {
            for (SocketChannel channel : socklist) {
                int read = channel.read(byteBuffer);
                if (read > 0) {
                    System.out.println("读取数据......" + read);
                    byteBuffer.flip();
                    byte[] bytes = new byte[read];
                    byteBuffer.get(bytes);
                    System.out.println(new String(bytes));
                    byteBuffer.clear();
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            SocketChannel socketChannel = serverSocket.accept();
            if (socketChannel != null) {
                System.out.println("成功连接......");
                socketChannel.configureBlocking(false);
                socklist.add(socketChannel);
                System.out.println("socketlist Size....." + socklist.size());
            }

        }
    }
}

上面代码就是NIO模型，它成功解决了BIO需要开启多线程的问题，NIO中一个线程就能解决多个socket，但是还存在两个问题。

  1. 这个模型在客户端少的时候非常好用，但是客户端如果多了，比如有1万个客户端进行连接，那么每次循环就是1万个socket，如果一万个socket中，只有10个socket有数据，也会遍历一万个socket，就会做很多无用功，每次遇到read返回-1仍然是一次浪费资源的系统调用。
  2. 而且这个遍历是在用户态进行的，用户态判断socket是否有数据还要调用内核的read()方法实现的，这就涉及到用户态和内核态的遍切换，每遍历一次就需要进行一次内核切换，这样开销是很大的。

怎么解决上述问题，方法是让linux搞定上述需求，我们将一批文件描述符通过一次系统调用传给内核层去遍历，才能真正解决这个问题。IO多路复用就这么产生了，也就是将上面工作交给内核，不再两态转换而是直接获取结果，因为内核是非阻塞的。

4. IO多路复用

多路复用：数据通信系统中或计算机网络系统中，传输媒体的带宽或容量往往会大于传输单一信号的需求，为了有效地利用通信线路，希望一个信道同时传输多路信号，这就是多路复用计数。采用多路复用技术能把多个信号组合在一条物理信道上进行传输，在远距离传输时可以大大节省电缆的安装和维护费用，频分多路复用（FDM）和时分多路复用（TDM）是两种最常用的多路复用技术。

在这里插入图片描述
在这里插入图片描述
nginx底层也是使用epoll接收请求，nginx会有很多连接进来，epoll会把它们都监视起来，然后像拔开关一样，谁有数据就拔向谁，然后调用相应的代码处理。

文件标识符（FileDescriptor）：文件标识符是计算机科学的一个术语，是一个用于表述指向文件引用的抽象化概念。文件描述符在形式上是一个非负整数，实际上它是一个索引值，指向内核为每一个进程所维护的改进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件的时候，内核向进程返回一个文件描述符。在程序设计中，一些底层的编码会往往围绕文件描述符来进行。但是文件描述符通常适用UNIX、Linux这样的操作系统。

IO多路复用：IO多路复用就是我们说的select、poll和epoll，有些技术书籍也称这种IO方式为event dirven IO。就是通过一种机制，一个进程可以监视多个文件描述符，一旦某个文件描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的写操作。可以基于一个阻塞的对象并同时在多个描述符上等待就绪，而不是使用多个线程（每个文件描述符就是一个线程，每次new一个线程），这样可以大大节省系统资源，所以，IO多路复用的特点就是通过一种机制一个进程能同时等待多个文件描述符而这些文件描述符（套接字描述符）其中任意一个进入读就绪状态，select、poll和epoll等函数的返回。

在这里插入图片描述

redis单线程为什么能够处理并发客户端连接，为什么这么快？

在这里插入图片描述

Reactor设计模式：基于IO复用模型，多个连接共用一个阻塞对象，应用程序只需要阻塞在一个对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始业务处理。Reactor模式，是指通过一个或多个同事传递给服务器处理的服务请求的时间驱动模型，服务端程序处理传入多路请求，并将它们同步分派给对应的处理线程，Reactor模型又称为Dispacher模式，即IO多路复用统一监听时间，收到时间后分发给线程，是编写高性能网络服务器的必备技术。

在这里插入图片描述
Reactor有两个关键部分：

Reactor：Reactor在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序对IO事件做出反应
Handler：处理程序执行IO事件要完成的实际操作

5. select、poll和epoll

select、poll和epoll都是IO多路复用的具体实现。

  • select方法：

在这里插入图片描述

select函数的执行流程如下：

  1. select是一个阻塞函数，当没有数据时，会一直阻塞在select
  2. 当有数据时会将reset中对应的那一个位置设置为1
  3. select函数返回，不再阻塞
  4. 遍历文件描述符数组，判断哪个fd被置位
  5. 读取数据，然后处理

在这里插入图片描述
在这里插入图片描述
总结：select其实就是把NIO中用户态要遍历的fd数组（Arraylist中的那个）拷贝到了内核态，让内核态来遍历，因为用户态判断socket是否有数据还是要调用内核态的，所有拷贝到内核态后，这样遍历判断的时候就不用一直在用户态和内核态之间频繁切换了。

缺点：

  1. bitmap的默认大小时1024个字节，虽然可以调整但还是有限度的
  2. reset每次循环都必须重新置位为0，不能重复使用
  3. 尽管将reset从用户态拷贝到了内核态，由内核态判断是否有数据，但是还是有拷贝的开销
  4. 当有数据时select就会返回，但是select函数并不知道哪个文件符有数据了，后面还需要对文件描述符进行遍历，效率比较低

在这里插入图片描述

  • poll方法

poll的执行流程：

  1. 将5个fd从用户态拷贝到核心态
  2. poll为阻塞方法，执行poll方法，如果有数据就会将fd对应的revents置为POLLIN
  3. poll方法返回
  4. 循环遍历，查找那个fd被置位为pollin了
  5. 将revents重置为0，便于复用
  6. 对置位的fd进行读取和处理

poll就解决了bitmap的大小限制，解决了reset不可重用的情况

在这里插入图片描述
poll使用pollfd数组来代替select中的bitmap，数组没有1024限制，可以一次管理多个client，它和select的主要区别是select只能监听1024个文件描述符的限制。当pollfds数组有事件发生时，相应的revents置为1，遍历的时候又置为0，实现pollfd数组的重用。poll虽然解决了select缺点中的前两条，其工作原理还是select方法，还存在select原来的问题：

  1. pollfds数组拷贝到内核态，仍然有开销
  2. poll并没有通知用户态哪一个有数据，仍需要O(N)遍历
  • epoll

epoll的主要组成：

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

epoll_create：创建一个句柄

epoll_ctl：向内核汇总添加、修改或删除文件描述符

epoll_wait：类似发起了selelct调用

epoll是非阻塞的，它的执行流程如下：

  1. 当有数据的时候，就会将相应的文件描述符置位，但是epoll没有revent标志位，所以并不是真正的置位，这时候会把有数据的文件符放到队首
  2. epoll会返回有数据的文件描述符的个数
  3. 根据返回的个数读取N个文件描述符即可
  4. 读取处理

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

  • 结论：多路复用快的原因在于，操作系统提供了这样的系统调用，使得原来的while循环里面的多次系统调用，变成了一次系统调用+内核层遍历这些文件描述符。epoll是现在最先进的IO多路复用器，redis、Nginx和linux中的java NIO都使用的是epoll。
  1. 一个socket的生命周期只有一次从用户态拷贝到内核态，开销小
  2. 使用event事件通知机制，每次socket有数据就主动通知内核，并加入到就绪链表中，不需要遍历所有的socket

在这里插入图片描述

jakiechaipush
关注
专栏目录
Redis单线程还是多线程？IO多路复用原理
学Java，找哪吒
03-23 6061
Redis实战系列，打造精品专栏。
redis中epoll模型-IO多路复用详情解析
qq_35475714的博客
11-15 466
阅读完redis中的网络模型源码,该文章会基于源码是如何去实现的角度，去介绍epoll模型、事件处理。以及基于此，自己实现的多人聊天终端系统，并附带源码。 1、epoll模型介绍 epoll 是Linux内核为处理大量并发网络连接而提出的解决方案，能显著提升系统CPU利用率。epoll使用非常简单，总共只有3个API : epoll_create函数创建一个epoll专用的文件描述符，用于后续epoll相关API调用; epoll_ctl函数向epoll注册、修改或删除需要监控的事件; epoll_wai
Redis底层多路复用
pengxiaozhang的博客
05-05 2545
Redis6：第十五篇-多路复用相关问题Redis的多路复用什么是IO多路复用文本事件同步异步阻塞非阻塞同步异步阻塞非阻塞 本篇文章是来复习Redis的多路复用以及相关知识 Redis的多路复用 什么是IO多路复用 Redis利用epoll来实现IO多路复用，将连接信息和事件放到队列中，一次性放到文本事件分派器，事件分派器把事件分给事件处理器 在上图中：用户有三个socket连接，一个是建立连接的socket server，一个设置key的连接，一个是获取key的连接，这三个连接去请求Redis，会先请求
Redis多路复用详解
最新发布
时间如瑾 代码如诗
07-22 1114
之前了解到阻塞IO和非阻塞IO, 无论是阻塞IO还是非阻塞IO，用户应用在一阶段都需要调用recvfrom来获取数据，差别在于无数据时的处理方案：如果调用recvfrom时，恰好没有数据，阻塞IO会使CPU阻塞，非阻塞IO使CPU空转，都不能充分发挥CPU的作用。如果调用recvfrom时，恰好有数据，则用户进程可以直接进入第二阶段，读取并处理数据所以怎么看起来以上两种方式性能都不好。
【redis学习】Redis-IO多路复用
weixin_47537043的博客
05-08 2310
网络IO在系统层面上指的是数据从用户态到内核态的读写操作，多路是指多个socket连接。在UNIX网络编程中写道为了执行网络IO，一个进程必须要做的第一件事就是调用socket函数。复用是指一个或多个连接处理。一个服务端进程可以同时处理多个套接字描述符。redis使用IO多路复用简单来说就是，单线程处理多个客户端连接的网络读写请求，并且能够保证不会阻塞主流程的一种机制。实现IO多路复用的模型有3种：可以分select->poll->epoll三个阶段来描述。
【Redis】高性能设计之epoll和IO多路复用深度解析
qq_43478625的博客
12-07 1474
文章目录一、Redis为什么快?高性能设计之epoll和IO多路复用深度解析1.1 Redis单线程如何处理那么多并发客户端连接，为什么单线程，为什么快?1.2 《Redis设计与实现》1.3 是什么?1.4 重要概念article同步异步同步与异步的理解阻塞非阻塞阻塞与非阻塞的理解总结1.5 Unix网络编程中的五种IO模型1.6 BIOjava验证演示acceptcode演示read案例1存在的问题案例2存在的问题1.7 NIO总结回答code案例存在问题和优缺点1.8 IO Multiplexing（
Redis 多路复用
旷野历程
12-23 4179
Redis 多路复用
【Redis】IO多路复用 及 Select、Poll、Epoll、NIO
火火的博客
12-17 2105
文章目录文件事件处理器【I/O多路复用程序】的实现文件事件的处理器连接应答处理器：命令请求处理器：命令回复处理器一次完整的客户端与服务器链接示例 文件事件处理器 Redis开发了一个文件事件处理器，文件事件处理器使用I/O多路复用（multiplexing）程序来同时监听多个套接字， 并根据套接字目前执行的任务来为套接字关联不同的事件处理器。 当被监听的套接字准备好执行 连接应答（accept）、读取（read）、写入（write）、关闭（close）等操作时， 与操作相对应的文件事件就会产生，此时，文件事
Redis 网络模型 -- 阻塞非阻塞IO、IO多路复用、epoll详解
m0_71777195的博客
10-29 1423
当用户进程调用了select，那么整个进程会被阻塞，而同时，内核会"监视"所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从内核拷贝到用户进程。这个模型和阻塞IO的模型其实并没有太大的不同，事实上还更差一些。因为这里需要使用两个系统调用(select和recvfrom)，而阻塞IO只调用了一个系统调用(recvfrom)。但是，用select的优势在于它可以同时处理多个连接。
Redis IO多路复用技术及epoll实现原理
泷泷养的乔小胖
09-17 4887
10、Redis IO多路复用技术以及epoll实现原理 Redis是一个单线程的但性能是非常好的内存数据库，主要用来作为缓存系统。Redis采用网络IO多路复用技术来保证在多连接的时候，系统吞吐量高。 10.1 为什么Redis要使用IO多路复用 首先，Redis是跑在单线程中的，所有的操作都是顺序线性执行的，但是由于读写操作等待用户输入或者输出都是阻塞的，所以...
二.Redis为什么这么快--分析Redis单线程以及IO多路复用的优点
KKKEVVINNN的博客
01-11 531
Redis为什么这么快--分析Redis单线程以及IO多路复用的优点
【Redis】IO多路复用机制
日拱一卒，不期速成！
05-15 4290
IO多路复用机制
网络模型-IO多路复用
admin3335的博客
10-19 711
网络模型-IO多路复用
Redis篇——超详细、超细节I/O多路复用介绍，回答Redis为什么单线程这么快！涵盖阻塞I/O模型、Linux内核空间以及Redis网络模型等常见技术点，一篇文章帮你彻底拿下！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
05-30 2062
redis为什么能够在单线程的情况下，轻松应对高并发的访问，Redis提供的I/O多路复用功不可没！Redis 使用 I/O 多路复用来处理连接，这意味着它不会为每个连接创建一个新的线程。而是使用一个主线程来监听多个连接，并在需要时进行处理。这种设计减少了线程切换的开销，并允许 Redis 在高并发场景下保持高性能。补充一下其他的帮助redis处理高并发请求的小帮手！事件驱动：Redis 使用事件驱动模型来处理请求。它监听套接字的 I/O 事件，一旦有数据可用，就立即处理。
Redis 和 I/O 多路复用
洋洋
04-17 475
最近在看 UNIX 网络编程并研究了一下 Redis 的实现，感觉 Redis 的源代码十分适合阅读和分析，其中 I/O 多路复用（mutiplexing）部分的实现非常干净和优雅，在这里想对这部分的内容进行简单的整理。 几种 I/O 模型 为什么 Redis 中要使用 I/O 多路复用这种技术呢？ 首先，Redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读
Redis的IO多路复用机制
Mamba Out
04-13 8491
文件事件处理器的四个部分:套接字、I/O多路复用程序、文件事件分发器、事件处理器 套接字socket 文件事件就是对套接字的抽象，每当一个套接字准备好执行连接、写入、读取、关闭等操作时，都会产生一个文件事件。 因为一个Redis服务器会有多个客户端连接，也就是说有多个套接字，所以多个文件事件可能会并发出现。 I/O多路复用程序 I/O多路复用程序，负责监听多个套接字，按照处理顺序，将套接字存放在一个队列中。 套接字队列以有序（sequentially）、同步（synchronously）、每...
Redis之epoll和IO多用复用
liming0025的专栏
02-13 2020
一、redsi的IO多路复用 redis利用epoll来实现IO多路复用，将连接信息和事件放入队列中，一次放到文件事件分派器，事件分派器将事件分发给事件处理器。 IO多路复用，使用的是linux内核函数，它的使用有三种select、poll、epoll，redis使用的就是epoll进行实现。 在redis中，多个客户端同时进行连接，redis使用epoll，把各个客户端的事件放到队列中，然后又事件派发器找到对应的工作单元。IO多路复用解决就是防止一个读写导致整个进程的阻塞。 Redis服务采用
redis的多路复用
qq_40058686的博客
03-26 902
redis是一个单进程单线程的内存数据库，主要用来作为缓存系统。采用了网络io多路复用技术来保证在多连接的时候的系统的吞吐量 为什么redis使用io多路复用技术？ 因为redis是单线程的，所有的操作都是按照顺序线性执行的，但是由于读写操作是阻塞的，所以某个请求假如是阻塞的话那么整个进程都无法对其他客户端提供服务。所以就有了io多路复用 redis的io多路复用模型是基于e...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值