JAVA IO模型演进及Reactor模式

一、传统BIO模型

在基于传统同步阻塞模型中：ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功后，双方通过输入输出流进行同步阻塞式通信。

通信过程：

1）服务端通常由一个独立的Acceptor线程负责监听客户端的连接；

2）Acceptor监听到客户端的连接请求后，为每个客户端创建一个新的线程进行链路处理；

3）链路处理线程完成客户端请求的处理后，通过输出流返回应答给客户端，然后线程销毁。

模型缺点：

1）服务端线程个数与客户端并发访问连接数是1：1的关系；

2）随着客户端并发访问量增大，服务端线程个数线性膨胀，系统性能急剧下降。

二、优化后的BIO模型

服务端通过线程池来处理多个客户端的接入请求，通过线程池约束及调配服务端线程资源。形成客户端个数M：服务端线程池最大线程数N的比例关系。

通信过程：

1）当有新的客户端接入时，将客户端Socket封装成一个Task投递到服务端任务队列；

2）服务端任务线程池中的多个线程对任务队列中的Task进行并行处理；

3）任务线程处理完当前Task后，继续从任务队列中取新的Task进行处理。

模型缺点：

1）BIO的读和写操作都是同步阻塞的，阻塞时间取决于对端IO线程的处理速度和网络IO的传输速度，可靠性差；

2）当线程池中所有线程都因对端IO线程处理速度慢导致阻塞时，所有后续接入的客户端连接请求都将在任务队列中排队阻塞堆积；

3）任务队列堆积满后，新的客户端连接请求将被服务端单线程Acceptor阻塞或拒绝，客户端会发生大量连接失败和连接超时。

三、NIO模型

多路复用器Selector是NIO模型的基础，一个多路复用器Selector可以同时轮询多个注册在它上面的Channel，服务端只需要一个线程负责Selector的轮询，就可以接入成千上万的客户端连接。

模型优点：

1）NIO中Channel是全双工的，Channel比流可以更好地映射底层操作系统的API（UNIX网络编程模型中，底层操作系统的通道都是全双工的，同时支持读写操作）；

2）客户端发起的连接操作是异步的，不需要像之前的客户端那样被同步阻塞；

3）JDK的Selector在Linux等主流操作系统上通过epoll实现，它没有连接句柄数的限制，使得一个Selector线程可以同时处理成千上万个客户端连接，而且性能不会随客户端连接的增加而线性下降，适合做高性能高负载的网络服务器方案。

四、AIO模型

NIO2.0的异步套接字通道是真正的异步非阻塞IO，对应于UNIX网络编程中的事件驱动IO（AIO）。

它不需要通过多路复用器Selector对注册的通道进行轮询操作即可实现异步读写。通过事件驱动+回调函数的方式完成。

五、几种IO模型的功能特性对比

六、NIO模型+Reactor模式的网络服务端

1、Reactor模式思想：分而治之+事件驱动

1）分而治之

一个connection里完整的网络处理过程一般分为accept、read、decode、process、encode、send这几步。

Reactor模式将每个步骤映射为一个Task，服务端线程执行的最小逻辑单元不再是一次完整的网络请求，而是Task，且采用非阻塞方式执行。

2）事件驱动

每个Task对应一个特定事件，当Task准备就绪时，对应的事件通知就会发出。

Reactor收到事件通知后，分发给绑定了对应事件的Handler执行Task。

2、单线程版本Reactor模式

1）结构图

Reactor：负责响应事件，将事件分发给绑定了该事件的Handler处理；

Handler：事件处理器，绑定了某类事件，负责执行对应事件的Task对事件进行处理；

Acceptor：Handler的一种，绑定了connect事件。当客户端发起connect请求时，Reactor会将accept事件分发给Acceptor处理。

2）客户端连接服务端

a、服务端将绑定了accept事件的Acceptor注册到Reactor中，准备accept新的connection;

b、服务端循环执行Reactor的多路复用器Selector的select功能，监听就绪事件；

c、客户端connect服务器；

d、Reactor的多路复用器监听到accept事件，分发给Acceptor处理事件；

e、Acceptor执行事件Task，接收建立与客户端的连接，并创建一个Handler用于执行该连接的后续请求事件；

f、Handler绑定连接的read事件，并将自己注册到Reactor的Selector中监听。

3）服务端处理客户端请求

a、客户端发送请求；

b、客户端请求到达服务端时，Reactor监听到read事件，将事件分发给对应Handler处理；

c、Handler处理read事件，异步读取客户端请求数据；

d、Handler解析(decode)客户端请求数据；

e、Handler处理(process)客户端请求；

f、Handler重新绑定write事件；

g、当连接可以开始write时，Reactor监听到write事件，将事件分发给Handler处理；

h、Handler处理write事件，异步写出服务端响应数据。

4）模型优缺点

a、单线程版本Reactor模型优点是不需要做并发控制，代码实现简单清晰；

b、缺点是不能利用多核CPU，一个线程需要执行处理所有的accept、read、decode、process、encode、send事件，如果其中decode、process、encode事件的处理很耗时，则服务端无法及时响应其他客户端的请求事件。

3、Reactor模式的其他版本

1）Worker threads

a、使用线程池执行数据的具体处理过程decode、process、encode，提高数据处理过程的响应速度；

b、Reactor所在单线程只需要专心监听处理客户端请求事件accept、read、write；

c、因为Reactor仍是单线程，无法并行响应多个客户端的请求事件（比如同一时刻只能read一个客户端的请求数据）。

2）Multiple reactor threads

a、采用多个Reactor，每个Reactor在自己单独线程中执行，可以并行响应多个客户端的请求事件；

b、Netty采用类似这种模式，boss线程池就是多个mainReactor，worker线程池就是多个subReactor。

注：以上内容参照《Netty权威指南》和网络文章

4、NIO单线程Reactor模式示例代码

package com.zhangyiwen.study.nio.reactor_demo;

import java.io.IOException;
import java.nio.channels.SelectionKey;

/**
 * Created by zhangyiwen on 16/11/8.
 */
public interface Handler {

    void handle(SelectionKey sk) throws IOException;
}

package com.zhangyiwen.study.nio.reactor_demo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

/**
 * Created by zhangyiwen on 16/11/7.
 */
public class EventHandler implements Handler{

    SocketChannel socketChannel;
    SelectionKey selectionKey;

    ByteBuffer readBuffer = ByteBuffer.allocate(MAXIN);
    ByteBuffer outBuffer = ByteBuffer.allocate(MAXOUT);

    static final int MAXIN = 256*1024;
    static final int MAXOUT = 256*1024;
    static final Charset charset = Charset.forName("UTF-8");

    EventHandler(SocketChannel socketChannel, Selector selector) throws IOException {
        this.socketChannel = socketChannel;
        // 用selector注册套接字，并返回对应的SelectionKey，同时设置Key的interest set为监听该连接上得read事件
        this.selectionKey = socketChannel.register(selector, SelectionKey.OP_READ);
        // 绑定handler
        this.selectionKey.attach(this);
    }

    @Override
    public void handle(SelectionKey sk) throws IOException{
        if (sk.isReadable()) {
            System.out.println("[event]read");
            read();
        } else if (sk.isWritable()) {
            System.out.println("[event]write");
            write();
        }
    }

    /**
     * 处理read事件
     * @throws IOException
     */
    private void read() throws IOException{
        // 读取数据
        readBuffer.clear();
        StringBuilder content = new StringBuilder();
        int readNum = socketChannel.read(readBuffer);
        if(readNum==0){
            return;
        }else if(readNum<0){
            throw new IOException("exception.");
        }else {
            readBuffer.flip();
            content.append(charset.decode(readBuffer)); //decode
        }
        while(socketChannel.read(readBuffer) > 0)
        {
            readBuffer.flip();
            content.append(charset.decode(readBuffer)); //decode
        }
        // 处理数据
        process(content.toString());
        //
        selectionKey.interestOps(SelectionKey.OP_WRITE);
    }

    /**
     * 处理客户端请求数据
     * @param content
     */
    private void process(String content) throws IOException{
        System.out.println("[receive from client] -> client:" + socketChannel.getRemoteAddress() + ", content: " + content);
        outBuffer = ByteBuffer.wrap(content.toUpperCase().getBytes());
    }

    /**
     * 处理write事件
     * @throws IOException
     */
    private void write() throws IOException {
        // 写数据
        socketChannel.write(outBuffer);
        if (outBuffer.remaining() > 0) {
            return;
        }
        //
        selectionKey.interestOps(SelectionKey.OP_READ);
    }
}

package com.zhangyiwen.study.nio.reactor_demo;

import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

/**
 * Created by zhangyiwen on 16/11/8.
 */
public class Acceptor implements Handler{

    static final Charset charset = Charset.forName("UTF-8");

    private ServerSocketChannel serverChannel;

    private Selector selector;

    public Acceptor(ServerSocketChannel serverChannel, Selector selector) {
        this.serverChannel = serverChannel;
        this.selector = selector;
    }

    @Override
    public void handle(SelectionKey sk) throws IOException{
        System.out.println("[event]connect");
        // 建立连接
        SocketChannel socketChannel = serverChannel.accept();
        System.out.println("[new client connected] client:" + socketChannel.getRemoteAddress());
        // 设置为非阻塞
        socketChannel.configureBlocking(false);
        // 创建Handler,专门处理该连接后续发生的OP_READ和OP_WRITE事件
        new EventHandler(socketChannel, this.selector);
        // 发送欢迎语
        socketChannel.write(charset.encode("welcome my client."));
    }

}

package com.zhangyiwen.study.nio.reactor_demo;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.Iterator;

/**
 * Created by zhangyiwen on 16/11/7.
 * 服务端,会先发欢迎语,后续会将客户端发来的消息转成大写后返回
 */
public class NioServer {

    private InetAddress hostAddress;

    private int port;

    private Selector selector;

    private ServerSocketChannel serverChannel;


    public NioServer(InetAddress hostAddress, int port) throws IOException {
        this.hostAddress = hostAddress;
        this.port = port;

        //初始化selector.绑定服务端监听套接字,感兴趣事件,对应的handler
        initSelector();
    }

    public static void main(String[] args) {
        try {
            // 启动服务器
            new NioServer(null, 9090).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 初始化selector,绑定服务端监听套接字、感兴趣事件及对应的handler
     * @return
     * @throws IOException
     */
    private void initSelector()throws IOException {
        // 创建一个selector
        selector = SelectorProvider.provider().openSelector();
        // 创建并打开ServerSocketChannel
        serverChannel = ServerSocketChannel.open();
        // 设置为非阻塞
        serverChannel.configureBlocking(false);
        // 绑定端口
        serverChannel.socket().bind(new InetSocketAddress(hostAddress, port));
        // 用selector注册套接字，并返回对应的SelectionKey，同时设置Key的interest set为监听客户端连接事件
        SelectionKey selectionKey = serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        // 绑定handler
        selectionKey.attach(new Acceptor(serverChannel,selector));
    }

    public void start() {
        while (true) {
            /*
             * 选择事件已经ready的selectionKey,该方法是阻塞的.
             * 只有当至少存在selectionKey,或者wakeup方法被调用,或者当前线程被中断,才会返回.
             */
            try {
                selector.select();
            } catch (IOException e) {
                e.printStackTrace();
            }

            // 循环处理每一个事件
            Iterator<SelectionKey> items = selector.selectedKeys().iterator();
            while (items.hasNext()) {
                SelectionKey key = items.next();
                items.remove();
                if (!key.isValid()) {
                    continue;
                }
                // 事件处理分发
                dispatch(key);
            }
        }
    }

    /**
     * 事件处理分发
     * @param sk 已经ready的selectionKey
     */
    private void dispatch(SelectionKey sk){
        // 获取绑定的handler
        Handler handler = (Handler) sk.attachment();
        try {
            if (handler != null) {
                handler.handle(sk);
            }
        } catch (IOException e) {
            e.printStackTrace();
            sk.channel();
            try {
                if(sk.channel()!=null){
                    sk.channel().close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }

}

package com.zhangyiwen.study.nio.reactor_demo;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Scanner;

/**
 * Created by zhangyiwen on 16/11/8.
 * 手动输入客户端
 */
public class NioClient {

    private InetAddress hostAddress;
    private int port;

    private Selector selector;
    private SocketChannel socketChannel;

    private ByteBuffer readBuffer = ByteBuffer.allocate(8192);
    static final Charset charset = Charset.forName("UTF-8");

    public NioClient(InetAddress hostAddress, int port) throws IOException {
        this.hostAddress = hostAddress;
        this.port = port;
        initSelector();
    }

    public static void main(String[] args) {
        try {
            new NioClient(InetAddress.getByName("localhost"), 9090);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void initSelector() throws IOException {
        // 创建一个selector
        selector = SelectorProvider.provider().openSelector();
        // 打开SocketChannel
        socketChannel = SocketChannel.open();
        // 设置为非阻塞
        socketChannel.configureBlocking(false);
        // 连接指定IP和端口的地址
        socketChannel.connect(new InetSocketAddress(this.hostAddress, this.port));
        // 用selector注册套接字，并返回对应的SelectionKey，同时设置Key的interest set为监听服务端已建立连接的事件
        socketChannel.register(selector, SelectionKey.OP_CONNECT);

        // 开启新线程执行
        new Thread(new ClientThread()).start();

        //在主线程中 从键盘读取数据输入到服务器端
        Scanner scan = new Scanner(System.in);
        while(scan.hasNextLine())
        {
            String line = scan.nextLine();
            if("".equals(line)) continue; //不允许发空消息
            socketChannel.write(charset.encode(line));//sc既能写也能读，这边是写
        }
    }

    private class ClientThread implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    selector.select();
                } catch (Exception e) {
                    e.printStackTrace();
                }

                Iterator<?> selectedKeys = selector.selectedKeys().iterator();
                while (selectedKeys.hasNext()) {
                    SelectionKey key = (SelectionKey) selectedKeys.next();
                    selectedKeys.remove();
                    if (!key.isValid()) {
                        continue;
                    }
                    dispatch(key);
                }
            }
        }

        /**
         * 事件处理分发
         * @param key 已经ready的selectionKey
         */
        private void dispatch(SelectionKey key){
            try {
                if (key.isConnectable()) {
                    System.out.println("[event]connect.");
                    finishConnection(key);
                } else if (key.isReadable()) {
                    System.out.println("[event]read");
                    read(key);
                }
            } catch (IOException e) {
                e.printStackTrace();
                key.channel();
                try {
                    if(key.channel()!=null){
                        key.channel().close();
                    }
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    /**
     * 完成与服务端连接
     * @param key
     * @throws IOException
     */
    private void finishConnection(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        // 判断连接是否建立成功，不成功会抛异常
        socketChannel.finishConnect();
        // 设置Key的interest set为OP_WRITE事件
        key.interestOps(SelectionKey.OP_READ);
    }

    /**
     * 处理read
     * @param key
     * @throws IOException
     */
    private void read(SelectionKey key) throws IOException {
        // 读取数据
        SocketChannel socketChannel = (SocketChannel) key.channel();
        readBuffer.clear();
        StringBuilder content = new StringBuilder();
        int readNum = socketChannel.read(readBuffer);
        if(readNum==0){
            return;
        }else if(readNum<0){
            throw new IOException("exception.");
        }else {
            readBuffer.flip();
            content.append(charset.decode(readBuffer)); //decode
        }
        while(socketChannel.read(readBuffer) > 0)
        {
            readBuffer.flip();
            content.append(charset.decode(readBuffer));
        }
        // 处理数据
        process(content.toString(), key);
        // 设置Key的interest set为OP_READ事件
//        key.interestOps(SelectionKey.OP_READ);
    }

    /**
     * 处理服务端响应数据
     * @param content
     */
    private void process(String content,SelectionKey key) {
        System.out.println("[Client receive from server] -> content: " + content);
    }


}