我要评论redis单线程是如何处理那么多并发客户端连接？为什么单线？为什么那么快？
这是因为redis使用了io多路复用，redis利用epoll来实现io多路复用，将连接信息和事件放到队列中，一次放到文件事件分派器，事件分派器将事件分发给事件处理器。
我们一般面试中都会这样回答，那么什么是io多路复用模型？epoll又是什么？首先我们先来了解一下unix网络编程的五种io模型。
unix网络编程的五种io模型
1、blocking io：阻塞io；
2、noneblocking io： 非阻塞io；
3、io multiplexing：io多路复用；
4、signal driven io：信号驱动io（略）；
5、asynchronous io：异步io（略）。
同步和异步
同步：调用者要一直等待调用结果的通知后才能进行后续的执行。现在就要，我可以等，等到结果为止。
异步：指被调用方先返回应答让调用者先回去，然后再计算调用结果，计算完最终结果再通知并返回给调用方。异步调用想要获取结果一般通过回调。
同步、异步的讨论对象是被调用者（服务提供者），重点在于获得调用结果的消息通知方式上。
阻塞和非阻塞
阻塞：调用方一直在等待且别的事情什么都不做，当前线 / 进程会被挂起，啥也不干。
非阻塞：调用在发出去后，调用方先去做别的事情，不会阻塞当前线 / 进程，而会立刻返回。
阻塞和非阻塞讨论的对象是调用者（服务请求者），重点在于等消息时候的行为，调用者是否能干其他事。
4种组合方式
同步阻塞、同步非阻塞、异步阻塞、异步非阻塞。
同步阻塞：服务员说快到你了，先别离开我后台看一眼马上通知你。客户在海底捞前台干等，啥也不干。
同步非阻塞：服务员说快到你了，先别离开。客户在海底捞前台边刷抖音边等叫号。
异步阻塞：服务员说还需要等位，你先去逛逛，一会通知你。客户怕过号在海底捞前台拿着排号小票啥也不干，就在那等着店员通知。
异步非阻塞：服务员说还需要等位，你先去逛逛，一会通知你。拿着排号小票，刷着抖音，等着店员通知。
bio
在阻塞式i/o模型中，应用程序在从调用rercvfrom开始到他返回有数据报准备好这段时间是阻塞的，recvfrom返回成功后，应用进程才能开始处理数据报。tomcat7之前就是用bio多线程来解决多连接。
accept监听
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");
}
}
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");
}
}public class redisserver
{
public static void main(string[] args) throws ioexception
{
serversocket serversocket = new serversocket(6379);
while(true)
{
system.out.println("模拟redisserver启动-----111 等待连接");
socket socket = serversocket.accept();
system.out.println("-----222 成功连接: "+ idutil.simpleuuid());
system.out.println();
}
}
}启动redisserver，并启动redisclient01，redisclient02。
read读取
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 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();
socket.close();
}
}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 scanner = new scanner(system.in);
string string = scanner.next();
if (string.equalsignorecase("quit")) {
break;
}
socket.getoutputstream().write(string.getbytes());
system.out.println("------redisclient02 input quit keyword to finish......");
}
outputstream.close();
socket.close();
}
}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 length = -1;
byte[] bytes = new byte[1024];
system.out.println("-----333 等待读取");
while((length = inputstream.read(bytes)) != -1)//阻塞2 ,等待客户端发送数据
{
system.out.println("-----444 成功读取"+new string(bytes,0,length));
system.out.println("===================="+"\t"+ idutil.simpleuuid());
system.out.println();
}
inputstream.close();
socket.close();
}
}
}启动redisserverbio，并启动redisclient01发送消息。
成功读取1号连接发送的消息，启动redisclient02发送消息。
发现并没有接收到2号连接发送的消息，这时我们退出1号连接。
成功接收到2号连接发送的消息。
上面的模型存在很大的问题，如果客户端与服务端建立了连接，如果这个连接的客户端迟迟不发数据，程就会一直堵塞在read()方法上，这样其他客户端也不能进行连接，也就是一次只能处理一个客户端，对客户很不友好。
可以利用多线程。只要连接了一个socket，操作系统分配一个线程来处理，这样read()方法堵塞在每个具体线程上而不堵塞主线程，就能操作多个socket了，哪个线程中的socket有数据，就读那个。socket，各取所需，灵活统一。程序服务端只负责监听是否有客户端连接，使用 accept() 阻塞。客户端1连接服务端，就开辟一个线程（thread1）来执行 read() 方法，程序服务端继续监听。客户端2连接服务端，也开辟一个线程（thread2）来执行 read() 方法，程序服务端继续监听。客户端3连接服务端，也开辟一个线程（thread3）来执行 read() 方法，程序服务端继续监听。任何一个线程上的socket有数据发送过来，read()就能立马读到，cpu就能进行处理。
改造代码：
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 length = -1;
byte[] bytes = new byte[1024];
system.out.println("-----333 等待读取"+ idutil.simpleuuid());
while((length = inputstream.read(bytes)) != -1)//阻塞2 ,等待客户端发送数据
{
system.out.println("-----444 成功读取"+new string(bytes,0,length));
system.out.println("====================");
system.out.println();
}
inputstream.close();
socket.close();
} catch (ioexception e) {
e.printstacktrace();
}
},thread.currentthread().getname()).start();
new thread().start();
}
}
}
启动redisserverbiomultithread，并启动redisclient01，redisclient02发送消息。
成功接收1号连接2号连接发送的消息，那么现在的bio多线程模型还有什么问题吗？
多线程模型：每来一个客户端，就要开辟一个线程，如果来1万个客户端，那就要开辟1万个线程。在操作系统中用户态不能直接开辟线程，需要调用内核来创建的一个线程，这其中还涉及到用户状态的切换（上下文的切换），十分耗资源。
解决方法：
第一个办法：使用线程池。这个在客户端连接少的情况下可以使用，但是用户量大的情况下，你不知道线程池要多大，太大了内存可能不够，也不可行。
第二个办法：nio（非阻塞式io）方式。因为read()方法堵塞了，所有要开辟多个线程，如果什么方法能使read()方法不堵塞，这样就不用开辟多个线程了，这就用到了另一个io模型，nio（非阻塞式io）。
nio
在nio模式中，一切都是非阻塞的：accept()方法是非阻塞的，如果没有客户端连接，就返回无连接标识。read()方法是非阻塞的，如果read()方法读取不到数据就返回空闲中标识，如果读取到数据时只阻塞read()方法读数据的时间。在nio模式中，只有一个线程：当一个客户端与服务端进行连接，这个socket就会加入到一个数组中，隔一段时间遍历一次，看这个socket的read()方法能否读到数据，这样一个线程就能处理多个客户端的连接和读取了。
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());
}
}
}
}
启动redisservernio，并启动redisclient01，redisclient02发送消息。
成功接收1号连接2号连接发送的消息，但是如何用单线程处理大量的连接呢？
io多路复用模型
i/o多路复用在英文中其实叫 i/o multiplexing 。多个socket复用一根网线这个功能是在内核＋驱动层实现的。i/o multiplexing 这里面的 multiplexing 指的其实是在单个线程通过记录跟踪每一个sock(i/o流)的状态来同时管理多个i/o流. 目的是尽量多的提高服务器的吞吐能力。大家都用过nginx，nginx使用epoll接收请求，ngnix会有很多链接进来， epoll会把他们都监视起来，然后像拨开关一样，谁有数据就拨向谁，然后调用相应的代码处理。redis类似同理。
i/o：网络i/o。
多路：多个客户端连接(连接就是套接字描述符，即 socket 或者 channel) ，指的是多条 tcp 连接复用: 用一个进程来处理多条的连接，使用单进程就能够实现同时处理多个客户端的连接实现了用一个进程来处理大量的用户连接。
io multiplexing就是我们说的select，poll，epoll，有些技术书籍也称这种io方式为event driven io事件驱动io。就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。可以基于一个阻塞对象并同时在多个描述符上等待就绪，而不是使用多个线程(每个文件描述符一个线程，每次new一个线程)，这样可以大大节省系统资源。所以，i/o 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select，poll，epoll等函数就可以返回。
文件描述符
文件描述符（file descriptor）计算机科学中的一个术语，是一个用于表述指向文件的引用的抽象化概念。文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。在程序设计中，一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于unix、linux这样的操作系统。
举例描述io多路复用模型
模拟一个tcp服务器处理30个客户socket，一个监考老师监考多个学生，谁举手就应答谁。假设你是一个监考老师，让30个学生解答一道竞赛考题，然后负责验收学生答卷，你有下面几个选择：
第一种选择：按顺序逐个验收，先验收a，然后是b，之后是c、d。。。这中间如果有一个学生卡住，全班都会被耽误,你用循环挨个处理socket，根本不具有并发能力。
第二种选择：你创建30个分身线程，每个分身线程检查一个学生的答案是否正确。 这种类似于为每一个用户创建一个进程或者线程处理连接。
第三种选择，你站在讲台上等，谁解答完谁举手。这时c、d举手，表示他们解答问题完毕，你下去依次检查c、d的答案，然后继续回到讲台上等。此时e、a又举手，然后去处理e和a。这种就是io复用模型。linux下的select、poll和epoll就是干这个的。
将用户socket对应的fd注册进epoll，然后epoll帮你监听哪些socket上有消息到达，这样就避免了大量的无用操作。此时的socket应该采用非阻塞模式。这样，整个过程只在调用select、poll、epoll这些调用的时候才会阻塞，收发客户消息是不会阻塞的，整个进程或者线程就被充分利用起来，这就是事件驱动，所谓的reactor反应模式。所谓 i/o 多路复用机制，就是说通过一种考试监考机制，一个老师可以监视多个考生，一旦某个考生举手想要交卷了，能够通知监考老师进行相应的收卷子或批改检查操作。所以这种机制需要调用班主任(select/poll/epoll)来配合。多个考生被同一个班主任监考，收完一个考试的卷子再处理其它人，无需等待所有考生，谁先举手就先响应谁，当又有考生举手要交卷，监考老师看到后从讲台走到考生位置，开始进行收卷处理。
reactor设计模式
基于 i/o 复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。reactor 模式，是指通过一个或多个输入同时传递给服务处理器的服务请求的事件驱动处理模式。服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，reactor 模式也叫 dispatcher 模式。即 i/o 多了复用统一监听事件，收到事件后分发(dispatch 给某进程)，是编写高性能网络服务器的必备技术。
reactor 模式中有 2 个关键组成：
1）reactor：reactor 在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对 io 事件做出反应。 它就像公司的电话接线员，它接听来自客户的电话并将线路转移到适当的联系人；
2）handlers：处理程序执行 i/o 事件要完成的实际事件，类似于客户想要与之交谈的公司中的实际办理人。reactor 通过调度适当的处理程序来响应 i/o 事件，处理程序执行非阻塞操作。
那么现在我们在再来看一下redis单线程是如何处理那么多并发客户端连接？为什么单线？为什么那么快？
redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以 i/o 操作在一般情况下往往不能直接返回，这会导致某一文件的 i/o 阻塞导致整个进程无法对其它客户提供服务，而 i/o 多路复用就是为了解决这个问题而出现。所谓 i/o 多路复用机制，就是说通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或写就绪），能够通知程序进行相应的读写操作。这种机制的使用需要 select 、 poll 、 epoll 来配合。多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。
redis 服务采用 reactor 的方式来实现文件事件处理器（每一个网络连接其实都对应一个文件描述符）
redis基于reactor模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、io多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以redis才叫单线程模型。
io多路复用的具体实现select、poll、epoll
select
select 其实就是把nio中用户态要遍历的fd数组(我们的每一个socket链接，安装进arraylist里面的那个)拷贝到了内核态，让内核态来遍历，因为用户态判断socket是否有数据还是要调用内核态的，所有拷贝到内核态后，这样遍历判断的时候就不用一直用户态和内核态频繁切换了。select方式，既做到了一个线程处理多个客户端连接（文件描述符），又减少了系统调用的开销（多个文件描述符只有一次 select 的系统调用 + n次就绪状态的文件描述符的 read 系统调用。
select函数的执行流程：
1、select是一个阻塞函数，当没有数据时，会一直阻塞在select那一行。
2、当有数据时会将rset中对应的那一位置为1。
3、select函数返回，不再阻塞。
4、遍历文件描述符数值，判断那个fd被置位了。
5、读取数据，然后处理。
优点：
select系统调用后，返回了一个置位后的&rset，这样用户态只需进行很简单的二进制比较，就能很快知道哪些socket需要read数据，有效提高了效率。
缺点：
1、bitmap最大1024位，一个进程最多只能处理1024个客户端。
2、&rset不可重用，每次socket有数据就相应的位会被置位。
3、文件描述符数组拷贝到了内核态(只不过无系统调用切换上下文的开销。（内核层可优化为异步事件通知）)，仍然有开销。select 调用需要传入 fd 数组，需要拷贝一份到内核，高并发场景下这样的拷贝消耗的资源是惊人的。（可优化为不复制）
4、select并没有通知用户态哪一个socket有数据，仍然需要o(n)的遍历。select 仅仅返回可读文件描述符的个数，具体哪个可读还是要用户自己遍历。（可优化为只返回给用户就绪的文件描述符，无需用户做无效的遍历）。
poll
poll的执行流程:
1、将五个fd从用户态拷贝到内核态。
2、poll为阻塞方法，执行poll方法，如果有数据会将fd对应的revents置为pollin。
3、poll方法返回。
4、循环遍历，查找哪个fd被置位为pollin了。
5、将revents重置为0便于复用。
6、对置位的fd进行读取和处理。
优点：
1、poll使用pollfd数组来代替select中的bitmap，数组没有1024的限制，可以一次管理更多的client。它和 select 的主要区别就是，去掉了 select 只能监听 1024 个文件描述符的限制。
2、当pollfds数组中有事件发生，相应的revents置位为1，遍历的时候又置位回零，实现了pollfd数组的重用。
缺点：
poll 解决了select缺点中的前两条，其本质原理还是select的方法，还存在select中原来的问题。
1、pollfds数组拷贝到了内核态，仍然有开销。
2、poll并没有通知用户态哪一个socket有数据，仍然需要o(n)的遍历。
epoll
epoll 是非阻赛的。
epoll的执行流程:
1、当有数据的时候，会把相应的文件描述符“置位”，但是epool没有revent标志位，所以并不是真正的置位。这时候会把有数据的文件描述符放到队首。
2、epoll会返回有数据的文件描述符的个数。
3、根据返回的个数 读取前n个文件描述符即可。
4、读取、处理。
三步调用：
1、epoll_create：创建一个epoll句柄。
2、epoll_ctl：向内核添加、修改或删除要监控的文件描述符。
3、epoll_wait：类似发起了select()调用。
总结
多路复用快的原因在于，操作系统提供了这样的系统调用，使得原来的 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性能的瓶颈。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。
发表评论