Redis高性能网络IO模型
一、redis性能及网络IO原理分析
1.1 redis性能分析
Redis的性能由哪些因素决定？
- 内存
- CPU
- 网络通信
Redis 为什么那么快?
- C语言实现，C语言在一定程度上还是比Java语言性能要高一些，因为C语言不需要经过JVM进行翻译。
- 纯内存I/O，内存I/O比磁盘I/O性能更快
- I/O多路复用，基于epoll的I/O多路复用技术，实现高吞吐网络I/O
- 单线程模型，单线程无法利用到多核CPU，但是在Redis中，性能瓶颈并不是在计算上，而是在I/O能力，所以单线程能够满足高并发的要求。 从另一个层面来说，单线程可以避免多线程的频繁上下文切换以及同步锁机制带来的性能开销。
从请求处理开始分析
当我们在客户端向Redis Server发送一条指令，并且得到Redis回复的整个过程中，Redis做了什么呢？
要处理命令，则redis必须完整地接收客户端的请求，并将命令解析出来，再将结果读出来，通过网络回写到客户端。整个工序分为以下几个部分：
- 接收，通过TCP接收到命令，可能会历经多次TCP包、ack、IO操作
- 解析，将命令取出来
- 执行，到对应的地方将value读出来
- 返回，将value通过TCP返回给客户端，如果value较大，则IO负荷会更重
其中解析和执行是纯cpu/内存操作，而接收和返回主要是IO操作，首先我们先来看通信的过程。
redis6之前支持IO单线程
redis6支持IO多线程
1.2 网络IO的通信原理
同样，我也画了一幅图来描述网络数据的传输流程，首先，对于TCP通信来说，每个TCP Socket的内核中都有一个发送缓冲区和一个接收缓冲区，接收缓冲区把数据缓存到内核，若应用进程一直没有调用Socket的read方法进行读取，那么该数据会一直被缓存在接收缓冲区内。不管进程是否读取Socket，对端发来的数据都会经过内核接收并缓存到Socket的内核接收缓冲区。read所要做的工作，就是把内核接收缓冲区中的数据复制到应用层用户的Buffer里。进程调用Socket的send发送数据的时候，一般情况下是将数据从应用层用户的Buffer里复制到Socket的内核发送缓冲区，然后send就会在上层返回。换句话说，send返回时，数据不一定会被发送到对端。
网卡中的缓冲区既不属于内核空间，也不属于用户空间。它属于硬件缓冲，允许网卡与操作系统之间有个缓冲； 内核缓冲区在内核空间，在内存中，用于内核程序，做为读或写往硬件的数据缓冲区； 用户缓冲区在用户空间，在内存中，用于用户程序，做为读取或写往硬件的数据缓冲区，网卡芯片收到网络数据会以中断的方式通知CPU，我有数据了，存在我的硬件缓冲里了，来读我啊。CPU收到这个中断信号后，会调用相应的驱动接口函数从网卡的硬件缓冲里把数据读到内核缓冲区，正常情况下会向上传递给TCP/IP模块一层一层的处理。
二、网络通信模型
最终目标: 增加客户端的访问连接数量
TCP/IP: ip:port访问目标服务的指定进程
2.1 BIO（阻塞IO模型）
ServerSocket
Socket
阻塞体现在两个地方：
- 连接阻塞
- IO阻塞
使用场景
- zookeeper的leader选举（3个节点， 5个节点）
- nacos的注册地址信息同步
在Java中，如果要实现网络通信，我们会采用Socket套接字来完成。Socket这不是一个协议，而是一个通信模型。其实它最初是BSD发明的，主要用来完成一台电脑的两个进程间通信，然后把它用到了两台电脑的进程间通信。所以，可以把它简单理解为进程间通信，不是什么高级的东西。主要做的事情不就是：
- A发包：发请求包给某个已经绑定的端口（所以我们经常会访问这样的地址182.13.15.16:1235，1235就是端口）；收到B的允许；然后正式发送；发送完了，告诉B要断开链接；收到断开允许，马上断开，然后发送已经断开信息给B。
- B收包：绑定端口和IP；然后在这个端口监听；接收到A的请求，发允许给A，并做好接收准备，主要就是清理缓存等待接收新数据；然后正式接收；接受到断开请求，允许断开；确认断开后，继续监听其它请求。
可见，Socket其实就是I/O操作，Socket并不仅限于网络通信，在网络通信中，它涵盖了网络层、传输层、会话层、表示层、应用层——其实这都不需要记，因为Socket通信时候用到了IP和端口，仅这两个就表明了它用到了网络层和传输层；而且它无视多台电脑通信的系统差别，所以它涉及了表示层；一般Socket都是基于一个应用程序的，所以会涉及到会话层和应用层。
2.1.1 构建基础的BIO通信模型
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class BIOServerSocket {
public static void main(String[] args) {
ServerSocket serverSocket=null;
try {
serverSocket=new ServerSocket(8080);
System.out.println("启动服务：监听端口:8080");
//表示阻塞等待监听一个客户端连接,返回的socket表示连接的客户端信息
while(true) {
Socket socket = serverSocket.accept(); //连接阻塞
System.out.println("客户端：" + socket.getPort());
//inputstream是阻塞的(***)
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream())); //表示获取客户端的请求报文
String clientStr = bufferedReader.readLine();
System.out.println("收到客户端发送的消息：" + clientStr);
Thread.sleep(20000); //增加等待时间
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bufferedWriter.write("receive a message:" + clientStr + "\n");
bufferedWriter.flush();
}
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(serverSocket!=null){
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
BIO有什么弊端呢？打开两个客户端(Telnet)同时向BIOServerSocket发起请求，运行后看到的现象应该是: client1先发送请求到Server端，由于Server端等待20s才返回，导致client2的请求一直被阻塞。这个情况会导致一个问题，如果服务端在同一个时刻只能处理一个客户端的连接，而如果一个网站同时有1000个用户访问，那么剩下的999个用户都需要等待，而这个等待的耗时取决于前面的请求的处理时长，如下图所示。
2.1.2 基于多线程优化BIO
为了让服务端能够同时处理更多的客户端连接，避免因为某个客户端连接阻塞导致后续请求被阻塞，于是引入多线程技术，代码如下。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
public class SocketThread implements Runnable{
private Socket socket;
public SocketThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
//inputstream是阻塞的(***)
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream())); //表示获取客户端的请求报文
String clientStr = bufferedReader.readLine();
System.out.println("收到客户端发送的消息：" + clientStr);
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bufferedWriter.write("receive a message:" + clientStr + "\n");
bufferedWriter.flush();
}catch (Exception e){
e.printStackTrace();
}finally {
//TODO 关闭IO流
}
}
}
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class BIOServerSocketWithThread {
static ExecutorService executorService= Executors.newFixedThreadPool(10);
public static void main(String[] args) {
ServerSocket serverSocket=null;
try {
serverSocket=new ServerSocket(8080);
System.out.println("启动服务：监听端口:8080");
//表示阻塞等待监听一个客户端连接,返回的socket表示连接的客户端信息
while(true) {
Socket socket = serverSocket.accept(); //连接阻塞
System.out.println("客户端：" + socket.getPort());
//IO变成了异步执行
executorService.submit(new SocketThread(socket));
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(serverSocket!=null){
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
如下图所示，当引入了多线程之后，每个客户端的连接（Socket），我们可以直接给到线程池去执行，而由于这个过程是异步的，所以并不会同步阻塞影响后续连接的监听，因此在一定程度上可以提升服务端连接的处理数量。
2.2 NIO（非阻塞IO)
把连接阻塞和IO阻塞改成非阻塞
2.2.1 NIO应用
使用BIO多线程的方式来解决高并发问题，仍然有一个缺点，线程的数量取决于硬件配置，所以线程数量是有限的，如果请求量比较大的时候，线程本身会受到限制从而并发量也不会太高。那怎么办呢，我们可以采用非阻塞IO。NIO 从JDK1.4 提出的，本意是New IO，它的出现为了弥补原本IO的不足，提供了更高效的方式，提出一个通道（channel）的概念，在IO中它始终以流的形式对数据进行传输和接收，下面我们演示一下NIO的使用。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
public class NIOServerSocket {
//NIO中的核心
//channel
//buffer
//selector
public static void main(String[] args) {
try {
ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false); //设置连接非阻塞
serverSocketChannel.socket().bind(new InetSocketAddress(8080));
while(true){
//是非阻塞的
SocketChannel socketChannel=serverSocketChannel.accept(); //获得一个客户端连接
// socketChannel.configureBlocking(false);//IO非阻塞
if(socketChannel!=null){
ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
int i=socketChannel.read(byteBuffer);
Thread.sleep(10000);
byteBuffer.flip(); //反转
socketChannel.write(byteBuffer);
}else{
Thread.sleep(1000);
System.out.println("连接位就绪");
}
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
所谓的NIO（非阻塞IO），其实就是取消了IO阻塞和连接阻塞，当服务端不存在阻塞的时候，就可以不断轮询处理客户端的请求，如下图所示，表示NIO下的运行流程。
上述这种NIO的使用方式，仍然存在一个问题，就是客户端或者服务端需要通过一个线程不断轮询才能获得结果，而这个轮询过程中会浪费线程资源。
2.2.2 多路复用IO
大家站在全局的角度再思考一下整个过程，有哪些地方可以优化呢？
我们看下面这段代码，当客户端通过 read 方法去读取服务端返回的数据时，如果此时服务端数据未准备好，对于客户端来说就是一次无效的轮询。我们能不能够设计成，当客户端调用 read 方法之后，不仅不阻塞，同时也不需要轮询。而是等到服务端的数据就绪之后， 告诉客户端。然后客户端再去读取服务端返回的数据呢？就像点外卖一样，我们在网上下单之后，继续做其它事情，等到外卖到了公司，外卖小哥主动打电话告诉你，你直接去前台取餐即可
while(true) {
int i = socketChannel.read(byteBuffer);
if (i > 0) {
System.out.println("收到服务端的数据：" + new String(byteBuffer.array()));
} else {
System.out.println("服务端数据未准备好");
Thread.sleep(1000);
}
}
所以为了优化这个问题，引入了多路复用机制。I/O多路复用的本质是通过一种机制（系统内核缓冲I/O数据），让单个进程可以监视多个文件描述符，一旦某个描述符就绪（一般是读就绪或写就绪），能够通知程序进行相应的读写操作。在linux中，内核把所有的外部设备都当成是一个文件来操作，对一个文件的读写会调用内核提供的系统命令，返回一个fd(文件描述符)。而对于一个socket的读写也会有相应的文件描述符，称为socketfd。常见的IO多路复用方式有【select、poll、epoll】，都是Linux API提供的IO复用方式，那么接下来重点讲一下select和epoll这两个模型
- select：进程可以把一个或者多个fd传递给select系统调用，进程会阻塞在select操作上，这样select可以帮我们检测多个fd是否处于就绪状态，这个模式有两个缺点：
1、由于他能够同时监听多个文件描述符，假如说有1000个，这个时候如果其中一个fd 处于就绪状态了，那么当前进程需要线性轮询所有的fd，也就是监听的fd越多，性能开销越大。
2、同时，select在单个进程中能打开的fd是有限制的，默认是1024，对于那些需要支持单机上万的TCP连接来说确实有点少 - epoll：linux还提供了epoll的系统调用，epoll是基于事件驱动方式来代替顺序扫描，因此性能相对来说更高，主要原理是，当被监听的fd中，有fd就绪时，会告知当前进程具体哪一个fd就绪，那么当前进程只需要去从指定的fd上读取数据即可，另外，epoll所能支持的fd上限是操作系统的最大文件句柄，这个数字要远远大于1024。【由于epoll能够通过事件告知应用进程哪个fd是可读的，所以我们也称这种IO为异步非阻塞IO，当然它是伪异步的，因为它还需要去把数据从内核同步复制到用户空间中，真正的异步非阻塞，应该是数据已经完全准备好了，我只需要从用户空间读就行】
I/O多路复用的好处是可以通过把多个I/O的阻塞复用到同一个select的阻塞上，从而使得系统在单线程的情况下可以同时处理多个客户端请求。它的最大优势是系统开销小，并且不需要创建新的进程或者线程，降低了系统的资源开销，它的整体实现思想如下图所示。客户端请求到服务端后，此时客户端在传输数据过程中，为了避免Server端在read客户端数据过程中阻塞，服务端会把该请求注册到Selector复路器上，服务端此时不需要等待，只需要启动一个线程，通过selector.select()阻塞轮询复路器上就绪的channel即可，也就是说，如果某个客户端连接数据传输完成，那么select()方法会返回就绪的channel，然后执行相关的处理即可。
Redis的通信采用的是多路复用机制
由于Redis是C语言实现，为了方便理解，我们采用Java语言来描述这个过程，以下代码是select多路复用实现。
import java.io.IOException;
import java.net.InetSocketAddress;
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.Iterator;
import java.util.Set;
public class NIOSelectorServerSocket implements Runnable{
Selector selector;
ServerSocketChannel serverSocketChannel;
public NIOSelectorServerSocket(int port) throws IOException {
selector=Selector.open();
serverSocketChannel=ServerSocketChannel.open();
//如果采用selector模型，必须要设置非阻塞
serverSocketChannel.configureBlocking(false);
serverSocketChannel.socket().bind(new InetSocketAddress(port));
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
}
@Override
public void run() {
while(!Thread.interrupted()){
try {
selector.select(); //阻塞等待事件就绪
Set selected=selector.selectedKeys(); //事件列表
Iterator it=selected.iterator();
while(it.hasNext()){
//说明有连接进来
dispatch((SelectionKey) it.next());
it.remove();//移除当前就绪的事件
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void dispatch(SelectionKey key) throws IOException {
if(key.isAcceptable()){ //是连接事件？
register(key);
}else if(key.isReadable()){ //读事件
read(key);
}else if(key.isWritable()){ //写事件
//TODO
}
}
private void register(SelectionKey key) throws IOException {
ServerSocketChannel channel= (ServerSocketChannel) key.channel(); //客户端连接
SocketChannel socketChannel=channel.accept(); //获得客户端连接
socketChannel.configureBlocking(false);
socketChannel.register(selector,SelectionKey.OP_READ);
}
private void read(SelectionKey key) throws IOException {
//得到的是socketChannel
SocketChannel channel= (SocketChannel) key.channel();
ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
channel.read(byteBuffer);
System.out.println("Server Receive Msg:"+new String(byteBuffer.array()));
}
public static void main(String[] args) throws IOException {
NIOSelectorServerSocket selectorServerSocket=new NIOSelectorServerSocket(8080);
new Thread(selectorServerSocket).start();
}
}
事实上NIO已经解决了上述BIO暴露的下面两个问题：
- 同步阻塞IO，读写阻塞，线程等待时间过长。
- 在制定线程策略的时候，只能根据CPU的数目来限定可用线程资源，不能根据连接并发数目来制定，也就是连接有限制。否则很难保证对客户端请求的高效和公平。
到这里为止，通过NIO的多路复用机制，解决了IO阻塞导致客户端连接处理受限的问题，服务端只需要一个线程就可以维护多个客户端，并且客户端的某个连接如果准备就绪时，会通过事件机制告诉应用程序某个channel可用，应用程序通过select方法选出就绪的channel进行处理。
2.3 单线程Reactor 模型
了解了NIO多路复用后，就有必要再和大家说一下Reactor多路复用高性能I/O设计模式，Reactor本质上就是基于NIO多路复用机制提出的一个高性能IO设计模式，它的核心思想是把响应IO事件和业务处理进行分离，通过一个或者多个线程来处理IO事件，然后将就绪得到事件分发到业务处理handlers线程去异步非阻塞处理，如下图所示。
Reactor模型有三个重要的组件：
- Reactor ：将I/O事件发派给对应的Handler
- Acceptor ：处理客户端连接请求
- Handlers ：执行非阻塞读/写
演示一个单线程的Reactor模型
Reactor.java
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set;
public class Reactor implements Runnable{
private final Selector selector;
private final ServerSocketChannel serverSocketChannel;
public Reactor(int port) throws IOException {
selector=Selector.open();
serverSocketChannel= ServerSocketChannel.open();
serverSocketChannel.socket().bind(new InetSocketAddress(port));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT,new Acceptor(selector,serverSocketChannel));
}
@Override
public void run() {
while(!Thread.interrupted()){
try {
selector.select();
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while(iterator.hasNext()){
dispatch(iterator.next());
iterator.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void dispatch(SelectionKey key){
//可能拿到的对象有两个
// Acceptor
// Handler
Runnable runnable=(Runnable)key.attachment();
if(runnable!=null){
runnable.run(); //
}
}
}
Acceptor.java
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
public class Acceptor implements Runnable{
private final Selector selector;
private final ServerSocketChannel serverSocketChannel;
public Acceptor(Selector selector, ServerSocketChannel serverSocketChannel) {
this.selector = selector;
this.serverSocketChannel = serverSocketChannel;
}
@Override
public void run() {
SocketChannel channel;
try {
channel=serverSocketChannel.accept();//得到一个客户端连接
System.out.println(channel.getRemoteAddress()+":收到一个客户端连接");
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ,new Handler(channel));
} catch (IOException e) {
e.printStackTrace();
}
}
}
Handler.java
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class Handler implements Runnable{
SocketChannel channe;
public Handler(SocketChannel channe) {
this.channe = channe;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"------");
ByteBuffer buffer=ByteBuffer.allocate(1024);
/*try {
Thread.sleep(1000000);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
int len=0,total=0;
String msg="";
try {
do {
len = channe.read(buffer);
if(len>0){
total+=len;
msg+=new String(buffer.array());
}
} while (len > buffer.capacity());
System.out.println("total:"+total);
//msg=表示通信传输报文
//耗时2s
//登录： username:password
//ServetRequets: 请求信息
//数据库的判断
//返回数据，通过channel写回到客户端
System.out.println(channe.getRemoteAddress()+": Server receive Msg:"+msg);
}catch (Exception e){
e.printStackTrace();
}finally {
if(channe!=null){
try {
channe.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
ReactorMain.java
import java.io.IOException;
public class ReactorMain {
public static void main(String[] args) throws IOException {
new Thread(new Reactor(8080),"Main-Thread").start();
}
}
这里演示的代码是最基本的单Reactor单线程模型（整体的I/O操作是由同一个线程完成的）。其中Reactor线程，负责多路分离套接字，有新连接到来触发connect 事件之后，交由Acceptor进行处理，有IO读写事件之后交给hanlder 处理。Acceptor主要任务就是构建handler ，在获取到和client相关的SocketChannel之后 ，绑定到相应的hanlder上，对应的SocketChannel有读写事件之后，基于reactor分发,hanlder就可以处理了（所有的IO事件都绑定到selector上，有Reactor分发）。Reactor 模式本质上指的是使用 I/O 多路复用(I/O multiplexing) + 非阻塞 I/O(non-blocking I/O) 的模式。
2.4 多线程单Reactor模型
单线程Reactor这种实现方式存在着缺点，从实例代码中可以看出，handler的执行是串行的，如果其中一个handler处理线程阻塞将导致其他的业务处理阻塞。由于handler和reactor在同一个线程中的执行，这也将导致新的handler无法接收新的请求，我们做一个小实验：
- 在上述Reactor代码的DispatchHandler的run方法中，增加一个Thread.sleep()。
- 打开多个客户端窗口连接到Reactor Server端，其中一个窗口发送一个信息后被阻塞，另外一个窗口再发信息时由于前面的请求阻塞导致后续请求无法被处理。
为了解决这种问题，有人提出使用多线程的方式来处理业务，也就是在业务处理的地方加入线程池异步处理，将reactor和handler在不同的线程来执行，如下图所示。
多线程改造-MultiDispatchHandler，我们直接将前面的Reactor单线程模型改成多线程，其实我们就是把IO阻塞的问题通过异步的方式做了优化。
MultiReactor.java
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set;
public class MultiReactor implements Runnable{
private final Selector selector;
private final ServerSocketChannel serverSocketChannel;
public MultiReactor(int port) throws IOException {
selector=Selector.open();
serverSocketChannel= ServerSocketChannel.open();
serverSocketChannel.socket().bind(new InetSocketAddress(port));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT,new MultiAcceptor(selector,serverSocketChannel));
}
@Override
public void run() {
while(!Thread.interrupted()){
try {
selector.select();
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while(iterator.hasNext()){
dispatch(iterator.next());
iterator.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void dispatch(SelectionKey key){
//可能拿到的对象有两个
// Acceptor
// Handler
Runnable runnable=(Runnable)key.attachment();
if(runnable!=null){
runnable.run(); //
}
}
}
MultiAcceptor.java
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
public class MultiAcceptor implements Runnable{
private final Selector selector;
private final ServerSocketChannel serverSocketChannel;
public MultiAcceptor(Selector selector, ServerSocketChannel serverSocketChannel) {
this.selector = selector;
this.serverSocketChannel = serverSocketChannel;
}
@Override
public void run() {
SocketChannel channel;
try {
channel=serverSocketChannel.accept();//得到一个客户端连接
System.out.println(channel.getRemoteAddress()+":收到一个客户端连接");
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ,new MutilDispatchHandler(channel));
} catch (IOException e) {
e.printStackTrace();
}
}
}
MutilDispatchHandler.java
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class MutilDispatchHandler implements Runnable{
SocketChannel channel;
private Executor executor= Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
public MutilDispatchHandler(SocketChannel channel) {
this.channel = channel;
}
@Override
public void run() {
processor();
}
private void processor(){
executor.execute(new ReaderHandler(channel));
}
static class ReaderHandler implements Runnable{
private SocketChannel channel;
public ReaderHandler(SocketChannel channel) {
this.channel = channel;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+":-----");
ByteBuffer buffer=ByteBuffer.allocate(1024);
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int len=0,total=0;
String msg="";
try {
do {
len = channel.read(buffer);
if(len>0){
total+=len;
msg+=new String(buffer.array());
}
} while (len > buffer.capacity());
System.out.println("total:"+total);
//msg=表示通信传输报文
//耗时2s
//登录： username:password
//ServetRequets: 请求信息
//数据库的判断
//返回数据，通过channel写回到客户端
System.out.println(channel.getRemoteAddress()+": Server receive Msg:"+msg);
}catch (Exception e){
e.printStackTrace();
}finally {
if(channel!=null){
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
MultiReactorMain.java
import java.io.IOException;
public class MultiReactorMain {
public static void main(String[] args) throws IOException {
new Thread(new MultiReactor(8080),"Main-Thread").start();
}
}
多线程Reactor总结：
在多线程Reactor模型中，添加了一个工作者线程池，并将非I/O操作从Reactor线程中移出转交给工作者线程池来执行。这样能够提高Reactor线程的I/O响应，不至于因为一些耗时的业务逻辑而延迟对后面I/O请求的处理。
2.5 多线程多Reactor模型
Reactor.java
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
public class Reactor implements Runnable{
private final Selector selector;
private ConcurrentLinkedQueue<AsyncHandler> events=new ConcurrentLinkedQueue<>();
public Reactor() throws IOException {
this.selector = Selector.open();
}
public Selector getSelector() {
return selector;
}
@Override
public void run() {
while(!Thread.interrupted()){
AsyncHandler handler;
try {
while((handler=events.poll())!=null){ //可以
handler.getChannel().configureBlocking(false);
SelectionKey selectionKey=handler.getChannel().register(selector,SelectionKey.OP_READ);
selectionKey.attach(handler);
handler.setSk(selectionKey);
}
selector.select();
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while(iterator.hasNext()){
SelectionKey key=iterator.next();
Runnable runnable=(Runnable) key.attachment(); //得到Acceptor实例
if(runnable!=null){
runnable.run();
}
iterator.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void register(AsyncHandler handler){
events.offer(handler); //有一个事件注册
selector.wakeup();
}
}
MultiplyReactor.java
import java.io.IOException;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class MultiplyReactor {
private int port;
private Reactor mainReactor; //main Reactor
Executor mainReactorExecutor= Executors.newFixedThreadPool(10);
public MultiplyReactor(int port) throws IOException {
this.port = port;
mainReactor=new Reactor();
}
public void start() throws IOException {
new Acceptor(mainReactor.getSelector(),port);
mainReactorExecutor.execute(mainReactor);
}
public static void main(String[] args) throws IOException {
new MultiplyReactor(8080).start();
}
}
Acceptor.java
import java.io.IOException;
import java.net.InetSocketAddress;
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.concurrent.Executor;
import java.util.concurrent.Executors;
public class Acceptor implements Runnable{
final Selector sel;
final ServerSocketChannel serverSocketChannel;
private final int POOL_SIZE=Runtime.getRuntime().availableProcessors();
private Executor subReactorExecutor= Executors.newFixedThreadPool(POOL_SIZE);
private Reactor[] subReactors=new Reactor[POOL_SIZE];
int handerNext=0;
public Acceptor(Selector sel,int port) throws IOException {
this.sel=sel;
this.serverSocketChannel=ServerSocketChannel.open();
this.serverSocketChannel.socket().bind(new InetSocketAddress(port));
this.serverSocketChannel.configureBlocking(false);
this.serverSocketChannel.register(this.sel, SelectionKey.OP_ACCEPT,this);
init();
System.out.println("Main Reactor Acceptor: Listening on port:"+port);
}
private void init() throws IOException {
for (int i = 0; i < subReactors.length; i++) {
subReactors[i]=new Reactor();
subReactorExecutor.execute(subReactors[i]);
}
}
@Override
public void run() {
//负责处理连接事件和IO事件
try {
SocketChannel socketChannel=serverSocketChannel.accept(); //获取连接
if(socketChannel!=null){
socketChannel.write(ByteBuffer.wrap("Multiply Reactor Patterm\r\nreactor> ".getBytes()));
System.out.println(Thread.currentThread().getName()+": Main-Reactor-Acceptor:"+socketChannel.getLocalAddress()+"连接");
Reactor subReactor=subReactors[handerNext];
subReactor.register(new AsyncHandler(socketChannel));
if(++handerNext==subReactors.length){
handerNext=0;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
AsyncHandler.java
import java.io.EOFException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
public class AsyncHandler implements Runnable{
private SocketChannel channel;
private SelectionKey sk;
StringBuilder stringBuilder=new StringBuilder();
ByteBuffer inputBuffer=ByteBuffer.allocate(1024);
ByteBuffer outputBuffer=ByteBuffer.allocate(1024);
public AsyncHandler(SocketChannel channel) {
this.channel = channel;
}
public SocketChannel getChannel() {
return channel;
}
public SelectionKey getSk() {
return sk;
}
public void setSk(SelectionKey sk) {
this.sk = sk;
}
@Override
public void run() {
try {
if (sk.isReadable()) {
read();
} else if (sk.isWritable()) {
write();
}
}catch (Exception e){
}
}
private void read() throws IOException {
inputBuffer.clear();
int n=channel.read(inputBuffer);
if(inputBufferComplete(n)){
System.out.println(Thread.currentThread().getName()+": Server端收到客户端的请求消息："+stringBuilder.toString());
outputBuffer.put(stringBuilder.toString().getBytes(StandardCharsets.UTF_8));
this.sk.interestOps(SelectionKey.OP_WRITE);
}
}
private boolean inputBufferComplete(int bytes) throws EOFException {
if(bytes>0){
inputBuffer.flip();
while(inputBuffer.hasRemaining()){
byte ch=inputBuffer.get(); //得到输入的字符
if(ch==3) { //表示Ctrl+c
throw new EOFException();
}else if(ch=='\r'||ch=='\n'){
return true;
}else {
stringBuilder.append((char)ch);
}
}
}else if(bytes==1){
throw new EOFException();
}
return false;
}
private void write() throws IOException {
int write=-1;
outputBuffer.flip();
if(outputBuffer.hasRemaining()){
write=channel.write(outputBuffer); //把收到的数据写回到客户端
}
outputBuffer.clear();
stringBuilder.delete(0,stringBuilder.length());
if(write<=0){
this.sk.channel().close();
}else{
channel.write(ByteBuffer.wrap("\r\nreactor> ".getBytes()));
this.sk.interestOps(SelectionKey.OP_READ);//又转化为读事件
}
}
}