Netty（七）：EventLoop学习前导——Reactor模式

了解Netty的人多少都会知道Netty的高性能的一个原因就是它是基于事件驱动的，而这一事件的原型就是Reactor模式。

所以在学习EventLoop前，很有必要先搞懂Reactor模式。

本文目录：

• 传统的服务器设计
• Basic Reactor（单线程模式）
• MultiThreadReactor（多线程模式）
• 主从多线程模型

传统的服务器设计模式：

　　先来简单的介绍下传统的服务器设计模式。

　　看从图例了解：

　　

　　传统的服务器设计模式是基于IO实现的。服务器在等待连接，及IO准备就绪前都会被阻塞。

　　代码示例如下：

　　

class Server implements Runnable {
    public void run() {
        try {
            ServerSocket ss = new ServerSocket(PORT);
            while (!Thread.interrupted())
            new Thread(new Handler(ss.accept())).start();      
        } catch (IOException ex) { /* ... */ }
    }
 
    static class Handler implements Runnable {
        final Socket socket;
        Handler(Socket s) { socket = s; }
        public void run() {
            try {
                byte[] input = new byte[MAX_INPUT];
                socket.getInputStream().read(input);
                byte[] output = process(input);
                socket.getOutputStream().write(output);
            } catch (IOException ex) { /* ... */ }
        }       
        private byte[] process(byte[] cmd) { /* ... */ }
    }
}

　传统的服务器模式的优势在于实现简便，相对于NIO的服务器，它的代码量更少，更直接。但它最大的缺点就是IO阻塞导致运行效率低下。

　Reactor模式:

　　Reactor模式是利用NIO的多路复用而设计的一种基于事件驱动的服务器模式。主要的设计目的是通过分而治之的思想让服务器实现可扩容的目标。

　　

　　Basic Reactor（单线程版本）：

　　Basic Reactor是Reactor模式最基础的版本，可以说是定义了整个Reactor模式的大骨架，其他复杂的版本也是在此基础上演变而来。

　　深入了解Basic Reactor是掌握Reactor模式的基本，因此我们会用最多的内容去理解Basic Reactor。

　　

　　无论是Reactor模式的哪些变化，基本上都离不开下列三种角色：

　　Reactor（反应堆）：服务器启动的主入口

　　Acceptor（接收器）：主要负责处理IO连接事件

　　Handler（处理器）：负责处理IO读写以及业务逻辑处理等

　　先结合图例来了解下Reactor：

　　

　　图中已经明显画出了Reactor和Acceptor的角色，而未画出的Handler部分就是黄色圆圈的部分（read，decode, compute, encode, send 构成了一个Handler的基本职能）

　　在通过代码来分析下：

　　

package com.insaneXs.netty.reactor.basic;

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;

/**
 * @Author: insaneXs
 * @Description:
 * @Date: Create at 2018-12-19
 */
public class Reactor implements Runnable{

    final Selector selector;

    final ServerSocketChannel serverSocket;

    Reactor(int port) throws Exception{

        //创建ServerSocketChannel，绑定端口，设置为非阻塞，选择器上注册ACCEPT事件
        selector = Selector.open();
        serverSocket = ServerSocketChannel.open();

        serverSocket.bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false);
        SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT);

        sk.attach(new Acceptor());
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                //阻塞，直到注册的事件发生
                selector.select();
                Set selected = selector.selectedKeys();
                Iterator it = selected.iterator();
                while (it.hasNext()){
                    //任务派发
                    dispatch((SelectionKey)(it.next()));
                }
                selected.clear();
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }

    }

    void dispatch(SelectionKey k) {
        //通过将不同的附件绑定到SelectionKey上，实现dispatch统一派发Acceptor和Handler的逻辑
        Runnable r = (Runnable)(k.attachment());
        if (r != null)
            r.run();
    }

    class Acceptor implements Runnable{
        @Override
        public void run() {
            try {
                //ACCEPT负责接收链接
                SocketChannel sc = serverSocket.accept();
                if(sc != null)
                    new Handler(selector, sc);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    class Handler implements Runnable{
        final SocketChannel socket;

        final SelectionKey sk;

        ByteBuffer input = ByteBuffer.allocate(1024);
        ByteBuffer output = ByteBuffer.allocate(1024);

        static final int READING = 0, SENDING = 1;
        int state = READING;

        Handler(Selector sel, SocketChannel c) throws IOException{
            socket = c;
            c.configureBlocking(false);
            // Optionally try first read now
            //返回了新的SelectionKey，将Handler添加为SelectionKey的附件，先注册READ事件
            sk = socket.register(sel, 0);
            sk.attach(this);
            sk.interestOps(SelectionKey.OP_READ);
            sel.wakeup();
        }

        boolean inputIsComplete() {
            return true;
        }
        boolean outputIsComplete() {
            return true;
        }
        void process() {
            //DO SOME THING
        }

        @Override
        public void run() {
            try {
                if (state == READING) read();
                else if (state == SENDING) send();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        void read() throws IOException {
            socket.read(input);
            if (inputIsComplete()) {
                process();
                state = SENDING;
            // Normally also do first write now
                sk.interestOps(SelectionKey.OP_WRITE);
            }
        }

        void send() throws IOException {
            socket.write(output);
            if (outputIsComplete()) sk.cancel();
        }

    }
}

　　了解完Reactor中的角色分工，再看代码其实并不复杂。代码关键的部分也都加上了注释。

　　每个角色的业务处理逻辑都是以run方法为入口，

　　Reactor中run方法处理的主要逻辑就是监听NIO的多路复用，并通过dispatch方法分发任务。

　　Acceptor中run方法处理的主要逻辑就是接收连接，并为处理读写做准备。

　　Handler中run方法处理的主要逻辑就是读写和业务逻辑的处理。

　　

　　有几点值得注意的：

　　第一，这段代码最关键的地方就是在Reactor进行任务分发时，利用SelectionKey的Attach添加附件的方法实现了用同一入口分发给Acceptor和Handler（这是设计的比较巧妙的部分）。

　　第二，无论是哪个角色都实现了Runnable，这也保证了即使是其他多线程版本，只需要修改部分代码，而不用动整个Reactor模式的骨架。

　　第三，我们可以看到上面的代码都是直接调用run方法，而不是通过Thread.start方法来运行，说明Basic Reactor的处理过程确实是单线程下的。

　　另外提到一点就是Handler的构造函数中先是register的0，然后再设置SelectionKey的interestOps为OP_READ。这点在之前的Netty源码分析中，我们也了解到，Netty正是这样的过程。　　

　　将代码转换成时序图，加深对代码的印象：

　　

　　Basic Reactor优点与不足：

　　优点：利用了NIO的特性，可以仅用一条线程处理多个通道的连接处理。相较于传统的服务器模式，这样对资源的消耗更少。

　　不足：我们可以看到不仅IO的部分由Reactor的线程处理，连业务处理的逻辑同样是放在Reactor的线程中处理，这样可能就会导致Reactor线程积累越来越多的请求，导致效率下降。

　　

　　MultiThreads版本的Reactor模型，正是为了解决上述的问题。

　　同样先通过图例来了解这个模式下，各个角色的关系：

　　

　　

　　这个图和Basic Reactor的区别是什么？我们又该如何理解呢？

　　我们可以看到之前的Handler处理的角色被一分为二，read,send（也就是IO的读写）和Basic Reactor中的模式不变，但是decode,compute,encode（也就是业务处理的逻辑）被拆出来，提交给ThreadPool运行。

　　

　　新的Reactor模式对比Basic Reactor，其他代码不变，只是我们修改了Handler，增加了一个新的角色，叫做Processor，作为负责处理业务逻辑的单元：

　　

public class ThreadPooledHandler implements Runnable{
    final SocketChannel socket;
    final SelectionKey sk;
    ByteBuffer input = ByteBuffer.allocate(1024);
    ByteBuffer output = ByteBuffer.allocate(1024);
    static final int READING = 0, SENDING = 1;
    static final int PROCESSING = 3;
    int state = READING;

    // uses util.concurrent thread pool
    static ExecutorService pool = Executors.newFixedThreadPool(4);

    ThreadPooledHandler(Selector sel, SocketChannel c) throws IOException {
        socket = c;
        c.configureBlocking(false);
        // Optionally try first read now
        //返回了新的SelectionKey，将Handler添加为SelectionKey的附件，先注册READ事件
        sk = socket.register(sel, 0);
        sk.attach(this);
        sk.interestOps(SelectionKey.OP_READ);
        sel.wakeup();
    }

    boolean inputIsComplete() {
        return true;
    }
    boolean outputIsComplete() {
        return true;
    }

    void process() {
        //DO SOME THING
    }

    @Override
    public void run() {
        try {
            if (state == READING) read();
            else if (state == SENDING) send();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    synchronized void read() throws IOException { // ...
        socket.read(input);
        if (inputIsComplete()) {
            state = PROCESSING;
            pool.execute(new Processer());
        }
    }

    void send() throws IOException {
        socket.write(output);
        if (outputIsComplete()) sk.cancel();
    }
    synchronized void processAndHandOff() {
        process();
        state = SENDING; // or rebind attachment
        sk.interestOps(SelectionKey.OP_WRITE);
    }

    //增加Processer角色，处理业务逻辑
    class Processer implements Runnable {
        public void run() { processAndHandOff(); }
    }

}

为了方便看出变化，我将两个版本的代码放在一起，做了对比图：

最大的区别就是原先Handler中process方法被交给了Processer执行，并且在执行时，是提交给线程池去执行。而Handler负责的IO读写逻辑仍然在Reactor的线程中执行（只是非网络IO的业务逻辑部分在新的线程中执行）。

相对于BasicReactor，这个版本的Reactor能更好的利用现代多核CPU的性能。让一条线程负责处理IO，而其他线程执行业务逻辑。多路复用上监听的阻塞，并不会阻塞业务逻辑的执行。

主从复合的Reactor模型

多线程的Reactor模型处理能力已经非常的高效，但是IO的连接过程仍然可能是个耗时的过程（比如SSL认证）。因此引出了一个新的变化——主从复合的Reactor模型。

先看图例：

 和上一个版本比较，这个版本的Reactor区别主要是将Reactor拆分一个MainReactor（负责处理Accept事件）和多个SubReactor（负责处理IO读写事件）。

而MainReactor和SubReactor的关联只要是通过Acceptor。

我们知道Reactor和Selector的关系是一对一的关系。通常一个Reactor由一条独立的线程执行。该线程在Reactor关联的Selector是监听事件。

因此这个模式下，当Accept在为连接进来的SocketChannel绑定Selector时，不再是绑定到MainReactor对应的Selector中，而是绑定到其他Reactor对应的Selector上（对应其他线程）。

这也因此让MainReactor只负责执行ACCEPT，而SubReactor负责IO读写。也使得ACCEPT上费时的操作将不会影响IO读写和业务逻辑处理。

贴上代码：

增加SubReactor:

public class SubReactor implements Runnable{
    private final Selector selector;

    public SubReactor() throws IOException {
        selector = Selector.open();
    }

    @Override
    public void run() {
        while(!Thread.interrupted()){
            try {
                selector.select();
                Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                while(iter.hasNext()){
                    SelectionKey sk = iter.next();
                    ((Runnable)sk.attachment()).run();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public Selector getSelector(){
        return selector;
    }
}

SubReactor的代码和Basic Reactor中Reactor的代码很相似，因为不处理连接部分，所以没有ServerSocketChannel和绑定监听端口的操作。

接下来看MainReactor和Acceptor的代码：

package com.insaneXs.netty.reactor.multiple;

import com.insaneXs.netty.reactor.threadpooled.ThreadPooledHandler;

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.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

/**
 * @Author: insaneXs
 * @Description:
 * @Date: Create at 2018-12-21
 */
public class MainReactor implements Runnable{
    final Selector selector;

    final ServerSocketChannel serverSocket;

    private final static int SUB_REACTOR_COUNT = 3;

    private final Selector[] selectors = new Selector[SUB_REACTOR_COUNT];

    MainReactor(int port) throws Exception{

        //创建ServerSocketChannel，绑定端口，设置为非阻塞，选择器上注册ACCEPT事件
        selector = Selector.open();
        serverSocket = ServerSocketChannel.open();

        serverSocket.bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false);
        SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT);

        for(int i=0; i<selectors.length; i++){

            //创建SUB-REACTOR，并保存对应的Selector对象
            SubReactor subReactor = new SubReactor();
            selectors[i] = subReactor.getSelector();
            //为SUB-REACTOR启动独立的线程
            new Thread(subReactor).start();
        }

        sk.attach(new Acceptor());
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                //阻塞，直到注册的事件发生
                selector.select();
                Set selected = selector.selectedKeys();
                Iterator it = selected.iterator();
                while (it.hasNext()){
                    //任务派发
                    dispatch((SelectionKey)(it.next()));
                }
                selected.clear();
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }

    }

    void dispatch(SelectionKey k) {
        //通过将不同的附件绑定到SelectionKey上，实现dispatch统一派发Acceptor和Handler的逻辑
        Runnable r = (Runnable)(k.attachment());
        if (r != null)
            r.run();
    }

    class Acceptor implements Runnable{
        private int idx = 0;
        @Override
        public void run() {
            try {
                //ACCEPT负责接收链接
                SocketChannel sc = serverSocket.accept();
                if(sc != null)//将SocketChannel与SubReactor的Selector均匀绑定
                    new ThreadPooledHandler(selectors[idx], sc);

                idx++;
                if(idx == SUB_REACTOR_COUNT)
                    idx = 0;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }



}

做个对比图，比较下和之前的版本的差异：

MainReactor:

区别主要在MainReactor内部保存了一些SubReactor，在MainReactor被创建时，同时创建了几个SubReactor。并且创建线程独立的运行SubReactor。

再看看Acceptor：

二者Acceptor的区别就是当把Handler提交给线程池时，非主从复合结构的版本仍然是用一个Selector。而主从复合结构的Handler在处理时，用的多路复用器是SubReactor中的。因此分离出了ACCEPT和IO读写。

本文参考：Scalable IO in Java

本文代码：Github