nginx 的反向代理也是采用了IO多路复用
I/O
多路
复用
总结
Redis 利用 epoll 来实现 IO多路复用，将连接信息和事件都放到队列中，一次放到文件事件分派器，事件分派器将事件分发给事件处理器
Redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以 I/O 操作在一般情况下往往不能直接返回，这会导致某一文件的 I/O 阻塞导致整个进程无法对其它客户提供服务，而 I/O 多路复用就是为了解决这个问题而出现
所谓 I/O 多路复用机制，就是说通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或写就绪），能够通知程序进行相应的读写操作。这种机制的使用需要 select 、 poll 、 epoll 来配合。多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。
Redis 服务采用 Reactor 的方式来实现文件事件处理器（每一个网络连接其实都对应一个文件描述符）
Redis基于Reactor模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：
多个套接字、
IO多路复用程序、
文件事件分派器、
事件处理器。
因为文件事件分派器队列的消费是单线程的，所以Redis才叫单线程模型
Reactor 模式要求 主线程（I/O 处理单元） 只负责监听文件描述符上是否有事件发生，有的话就立即将该事件通知工作线程（逻辑单元）。除此之外，主线程不做任何其他实质性的工作。 读写数据，接受新的连接，以及处理客户请求均在工作线程中完成。
从Redis6开始，将网络数据读写、请求协议解析通过多个IO线程的来处理 ，对于真正的命令执行来说，仍然使用单线程操作
同步
异步
同步与异步的理解
阻塞
非阻塞
阻塞与非阻塞的理解
总结
RedisServer
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:17
*/
public class RedisServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(6379);
while(true){
System.out.println("模拟redisServcer启动 -----111 等待连接");
Socket socket = serverSocket.accept();
System.out.println("---222 连接成功 " + UUID.randomUUID());
System.out.println();
}
}
}
RedisClient01
import java.io.IOException;
import java.net.Socket;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:09
*/
public class RedisClient01 {
public static void main(String[] args) throws IOException {
System.out.println("------RedisClient01 start ");
Socket socket = new Socket("127.0.0.1", 6379);
System.out.println("------RedisClient01 connection over ");
}
}
RedisClient02
import java.io.IOException;
import java.net.Socket;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:09
*/
public class RedisClient02 {
public static void main(String[] args) throws IOException {
System.out.println("------RedisClient02 start ");
Socket socket = new Socket("127.0.0.1", 6379);
System.out.println("------RedisClient02 connection over ");
}
}
测试 先启动redisServer，在启动redisClient
单线程模式测试
先启动 RedisServerBIO，再启动 RedisClient01 验证后再启动 2号客户端
RedisServerBIO
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:25
*/
public class RedisServerBIO {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(6379);
while (true) {
System.out.println("---111 等待连接");
Socket socket = serverSocket.accept(); // 阻塞1，等待客户端连接
System.out.println("---222 成功连接");
InputStream inputStream = socket.getInputStream();
int lenth = 1;
byte[] bytes = new byte[1024];
System.out.println("---333 等待读取");
while ((lenth = inputStream.read(bytes)) != -1){ // 阻塞2 等待客户端发送数据
System.out.println("---444 成功读取" + new String(bytes, 0, lenth));
System.out.println("=========" + UUID.randomUUID());
System.out.println();
}
inputStream.close();
socket.close();
}
}
}
RedisClient01
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:22
*/
public class RedisClient01 {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("127.0.0.1", 6379);
OutputStream outputStream = socket.getOutputStream();
while (true) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if (str.equalsIgnoreCase("quit")) {
break;
}
socket.getOutputStream().write(str.getBytes());
System.out.println("-----RedisClient01 input quit keyword to finish");
}
outputStream.close();
socket.close();
}
}
RedisClient02
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:22
*/
public class RedisClient02 {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("127.0.0.1", 6379);
OutputStream outputStream = socket.getOutputStream();
while (true) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if (str.equalsIgnoreCase("quit")) {
break;
}
socket.getOutputStream().write(str.getBytes());
System.out.println("-----RedisClient02 input quit keyword to finish");
}
outputStream.close();
socket.close();
}
}
测试
多线程模式
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:25
*/
public class RedisServerBIOMultiThread {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(6379);
while (true) {
System.out.println("--------RedisServerBIOMultiThread 111 等待连接");
Socket socket = serverSocket.accept(); // 阻塞1，等待客户端连接
System.out.println("--------RedisServerBIOMultiThread 222 成功连接");
new Thread(() -> {
try {
InputStream inputStream = socket.getInputStream();
int lenth = 1;
byte[] bytes = new byte[1024];
System.out.println("---333 等待读取");
while ((lenth = inputStream.read(bytes)) != -1) { // 阻塞2 等待客户端发送数据
System.out.println("---444 成功读取" + new String(bytes, 0, lenth));
System.out.println("=========" + UUID.randomUUID());
System.out.println();
}
inputStream.close();
socket.close();
}catch (Exception e) {
e.printStackTrace();
}
}, Thread.currentThread().getName()).start();
}
}
}
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:22
*/
public class RedisClient01 {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("127.0.0.1", 6379);
OutputStream outputStream = socket.getOutputStream();
while (true) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if (str.equalsIgnoreCase("quit")) {
break;
}
socket.getOutputStream().write(str.getBytes());
System.out.println("-----RedisClient01 input quit keyword to finish");
}
outputStream.close();
socket.close();
}
}
RedisClient02
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:22
*/
public class RedisClient02 {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("127.0.0.1", 6379);
OutputStream outputStream = socket.getOutputStream();
while (true) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if (str.equalsIgnoreCase("quit")) {
break;
}
socket.getOutputStream().write(str.getBytes());
System.out.println("-----RedisClient02 input quit keyword to finish");
}
outputStream.close();
socket.close();
}
}
测试
在NIO模式中，一切都是非阻塞的：
在NIO模式中，只有一个线程：
当一个客户端与服务端进行连接，这个socket就会加入到一个数组中，隔一段时间遍历一次
看这个socket的read()方法能否读到数据，这样一个线程就能处理多个客户端的连接和读取了
非阻塞在java中使用 ServerSocketChannel类
RedisServerNIO
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
/**
* @author 晓风残月Lx
* @date 2023/4/5 10:07
*/
public class RedisServerNIO {
static ArrayList<SocketChannel> socketList = new ArrayList<>();
static ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
public static void main(String[] args) throws IOException {
System.out.println("---------RedisServerNIO 启动等待中......");
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.bind(new InetSocketAddress("127.0.0.1", 6379));
serverSocket.configureBlocking(false);//设置为非阻塞模式
while (true) {
for (SocketChannel element : socketList) {
int read = element.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();
}
}
SocketChannel socketChannel = serverSocket.accept();
if (socketChannel != null) {
System.out.println("-----成功连接: ");
socketChannel.configureBlocking(false);//设置为非阻塞模式
socketList.add(socketChannel);
System.out.println("-----socketList size: " + socketList.size());
}
}
}
}
RedisClient01
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:22
*/
public class RedisClient01 {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("127.0.0.1", 6379);
OutputStream outputStream = socket.getOutputStream();
while (true) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if (str.equalsIgnoreCase("quit")) {
break;
}
socket.getOutputStream().write(str.getBytes());
System.out.println("-----RedisClient01 input quit keyword to finish");
}
outputStream.close();
socket.close();
}
}
RedisClient02
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
/**
* @author 晓风残月Lx
* @date 2023/4/5 9:22
*/
public class RedisClient02 {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("127.0.0.1", 6379);
OutputStream outputStream = socket.getOutputStream();
while (true) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if (str.equalsIgnoreCase("quit")) {
break;
}
socket.getOutputStream().write(str.getBytes());
System.out.println("-----RedisClient02 input quit keyword to finish");
}
outputStream.close();
socket.close();
}
}
测试
Redis利用epoll来实现IO多路复用，将连接信息和事件放到队列中，依次放到事件分派器，事件分派器将事件分发给事件处理器。
Redis 服务采用 Reactor 的方式来实现文件事件处理器（每一个网络连接其实都对应一个文件描述符）
所谓 I/O 多路复用机制，就是说通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或写就绪），能够通知程序进行相应的读写操作。这种机制的使用需要 select 、 poll 、 epoll 来配合。多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。
基于 I/O 复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。
Reactor 模式，是指通过一个或多个输入同时传递给服务处理器的服务请求的事件驱动处理模式。服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，Reactor 模式也叫 Dispatcher 模式。即 I/O 多了复用统一监听事件，收到事件后分发(Dispatch 给某进程)，是编写高性能网络服务器的必备技术！
Reactor 模式中有 2 个关键组成：
1）Reactor：Reactor 在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对 IO 事件做出反应。 它就像公司的电话接线员，它接听来自客户的电话并将线路转移到适当的联系人；
2）Handlers：处理程序执行 I/O 事件要完成的实际事件，类似于客户想要与之交谈的公司中的实际办理人。Reactor 通过调度适当的处理程序来响应 I/O 事件，处理程序执行非阻塞操作。
Redis 服务采用 Reactor 的方式来实现文件事件处理器（每一个网络连接其实都对应一个文件描述符）
Redis基于Reactor模式开发了网络事件处理器，这个处理器被称为文件事件处理器。
它的组成结构为4部分：
多个套接字、
IO多路复用程序、
文件事件分派器、
事件处理器。因为文件事件分派器队列的消费是单线程的，所以Redis才叫单线程模型
select、poll、epoll 都是 I/O 多路服用的具体的实现
/**
* select 其实就是把NIO 中用户态要遍历的fd（文件描述符）数组（我们的每一个socket链接，安装进ArrayList 里面的那个）拷贝到了内核态，
* 让内核态来遍历，因为用户态判断socket是否有数据还是要调用内核态的，所有拷贝到内核态后，这样遍历和判断的时候就不用一直用户态和内核态频繁切换
*/
while (true) {
for (SocketChannel element : socketList) {
int read = element.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();
}
}
SocketChannel socketChannel = serverSocket.accept();
if (socketChannel != null) {
System.out.println("-----成功连接: ");
socketChannel.configureBlocking(false);//设置为非阻塞模式
socketList.add(socketChannel);
System.out.println("-----socketList size: " + socketList.size());
}
}
select函数的执行分析流程
select方式，既做到了一个线程处理多个客户端连接（文件描述符），又减少了系统调用的开销（多个文件描述符只有一次 select 的系统调用 + N次就绪状态的文件描述符的 read 系统调用
执行流程分析
1、poll使用pollfd数组来代替select中的bitmap，数组没有1024的限制，可以一次管理更多的client。它和 select 的主要区别就是，去掉了 select 只能监听 1024 个文件描述符的限制。
2、当pollfds数组中有事件发生，相应的revents置位为1，遍历的时候又置位回零，实现了pollfd数组的重用
epoll_create
epoll_ctl
epoll_wait
执行流程（epoll非阻塞的）
多路复用快的原因在于，操作系统提供了这样的系统调用，使得原来的 while 循环里多次系统调用，变成了一次系统调用 + 内核层遍历这些文件描述符。
epoll是现在最先进的IO多路复用器，Redis、Nginx，linux中的Java NIO都使用的是epoll。
这里“多路”指的是多个网络连接，“复用”指的是复用同一个线程。
1、一个socket的生命周期中只有一次从用户态拷贝到内核态的过程，开销小
2、使用event事件通知机制，每次socket中有数据会主动通知内核，并加入到就绪链表中，不需要遍历所有的socket
在多路复用IO模型中，会有一个内核线程不断地去轮询多个 socket 的状态，只有当真正读写事件发送时，才真正调用实际的IO读写操作。因为在多路复用IO模型中，只需要使用一个线程就可以管理多个socket，系统不需要建立新的进程或者线程，也不必维护这些线程和进程，并且只有真正有读写事件进行时，才会使用IO资源，所以它大大减少来资源占用。多路I/O复用模型是利用 select、poll、epoll 可以同时监察多个流的 I/O 事件的能力，在空闲的时候，会把当前线程阻塞掉，当有一个或多个流有 I/O 事件时，就从阻塞态中唤醒，于是程序就会轮询一遍所有的流（epoll 是只轮询那些真正发出了事件的流），并且只依次顺序的处理就绪的流，这种做法就避免了大量的无用操作。 采用多路 I/O 复用技术可以让单个线程高效的处理多个连接请求（尽量减少网络 IO 的时间消耗），且 Redis 在内存中操作数据的速度非常快，也就是说内存内的操作不会成为影响Redis性能的瓶颈
PS： 尽量不要用 windows 的redis，只能调用select()方法，时间复杂度是O(n), Linux是用epoll()，时间复杂度O(1)，所以 Linux 的 redis 会比 windows 的快！！！
