NIO和Reactor

本文参考Doug Lea的Scalable IO in Java.

网络服务

随着网络服务的越来越多，我们对网络服务的性能有了更高的要求，提供一个高性能，稳定的web服务是一件很麻烦的事情，所以有了netty框架帮我们完成。

我们对各种各样的网络服务进行抽象，得到最基本的业务流程：

1：读取请求信息

2：对请求信息进行解码

3：进行相关的业务处理

4：对处理结果进行编码

5：发送请求

看到这，netty的ChannelHandler就是干这几件事情的。

传统的网络服务

在jdk1.4之前，我们只有BIO，所以当时的网络服务的架构是这样的。

每个线程处理一个请求， 由于线程个数和cpu个数的原因，这种设计性能是有上限的，所以就有了集群模式：tomcat集群。

/**
 * Created by gaoxing on 2015-01-20 .
 */
public class ClasssicServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket=new ServerSocket(8888,10);
            System.out.println("server is start");
            while( ! Thread.interrupted())
            {
                new Thread(new Handler(serverSocket.accept())).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    static class Handler implements  Runnable
    {
        final Socket socket;

        final static int MAX_SIZE=1024;

        public Handler(Socket socket)
        {
            this.socket=socket;
        }

        @Override
        public void run() {
            //TODO
            //在这里对socket中的数据进行读取和处理，然后把结果写入到socket中去
        }

    }
}

高性能的IO目标和Reactor

1：高负载下可以稳定的工作

2：提高资源的利用率

3：低延迟

这有就有了分而治之和事件驱动的思想。这样没有thread就不用瞎跑了，cpu就不用不停的切换Thread . 这样提出了Reactor模式

1：Reactor接收IO事件发送给该事件的处理器处理

2：处理器的操作是非阻塞的。

3：管理事件和处理器的绑定。

这是一个单线程版本，所有的请求都是一个线程处理，当然Reactor不是无缘无故的提出来的，因为jdk提供了nio包，nio使得Reator得于实现

1：channels: 通道就是数据源的抽象，通过它可以无阻塞的读取数据

2：buffers  : 用来装载数据的，可以把从channel读取到buffer中，或者把buffer中的数据写入到channel中

3：selector : 用来监听 有IO事件，并告诉channel

4：selectionkeys:  IO事件和处理器绑定

/**
 * Created by gaoxing on 2015-01-20 .
 */
public class Reactor implements Runnable {
    final Selector selector ;
    final ServerSocketChannel serverSocketChannel;

    public Reactor(int port) throws IOException {
        this.selector=Selector.open();
        this.serverSocketChannel=ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        //一定是非阻塞的，阻塞的一个通道就只能处理一个请求了
        serverSocketChannel.configureBlocking(false);
        //把OP_ACCEPT事件和Acceptor绑定
        SelectionKey sk=serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
        sk.attach(new Acceptor());

    }

    @Override
    public void run() {
        while(!Thread.interrupted())
        {
            try {
                selector.select();//该方法是阻塞的，只有IO事件来了才向下执行
                Set<SelectionKey> selected=selector.selectedKeys();
                Iterator<SelectionKey> it=selected.iterator();
                while(it.hasNext())
                {
                    dispatch(it.next());
                }
　　　　　　　　　 selected.clear()　　　　　　　　　　
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    private void dispatch(SelectionKey next) {
        Runnable runnable= (Runnable) next.attachment();
        if(runnable!=null)
        {
            runnable.run();
        }
    }

    private class Acceptor implements Runnable{
        @Override
        public void run() {
            SocketChannel channel= null;
            try {
                channel = serverSocketChannel.accept();
                if (channel!=null){
                    new Handler(selector,channel);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

class Handler implements  Runnable
{
    final SelectionKey sk;
    final SocketChannel channel;
    final static int MAXSIZE=1024;
    ByteBuffer input=ByteBuffer.allocate(MAXSIZE);
    ByteBuffer output=ByteBuffer.allocate(MAXSIZE);

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

    public Handler(Selector selector,SocketChannel channel) throws IOException {
        this.channel=channel;

            this.channel.configureBlocking(false);
            /**
             * 这个有个问题，ppt上register是0，
             */
            sk=this.channel.register(selector,SelectionKey.OP_READ);
            sk.attach(this);
            /**
             * 这里的作用是，设置key的状态为可读，然后让后selector的selector返回。
             * 然后就可以处理OP_READ事件了
             */
            sk.interestOps(SelectionKey.OP_READ);
            selector.wakeup();

    }
    @Override
    public void run() {
        if (state==READING) read();
        if (state==SENDING) write();
    }

    void read(){
        state=SENDING;
        sk.interestOps(SelectionKey.OP_WRITE);
    }

    void write()
    {
        sk.cancel();
    }
}

上面代码注解理解有误：

sk=this.channel.register(selector,0);  这里是初始化一个SelectionKey 不监听事件

sk.interestOps(SelectionKey.OP_READ); 这里设置监听的事件为OP_READ

多线程的Reactor模式

现在的CPU多核的，为了提高对硬件的使用效率需要考虑使用多线程的Reactor设计模式，Reactor主要用来处罚事件的，但是事件的处理会降低Reactor的性能，考虑把事件的处理放到别的线程上来做，有点想android的设计模式，UI线程用来接收用户的事件，事件的处理放到线程去做来提高用户的体验。多线程Reactor有两种一种是Reactor线程只关注io事件，事件处理放到别的线程，一种对事件分类主Reactor只关注Accept事件，子Reactor关注read和write事件。事件处理放到线程去做，这也是netty的设计模式。

class HandlerPool implements  Runnable
{
    final SelectionKey sk;
    final SocketChannel channel;
    final static int MAXSIZE=1024;
    ByteBuffer input=ByteBuffer.allocate(MAXSIZE);
    ByteBuffer output=ByteBuffer.allocate(MAXSIZE);
    static ExecutorService executor = Executors.newFixedThreadPool(100);
    static final int READING=0,SENDING=1;
    int state=READING;

    public HandlerPool(Selector selector,SocketChannel channel) throws IOException {
        this.channel=channel;

        this.channel.configureBlocking(false);
        /**
         * 这个有个问题，这里注册的SelectionKey是不处理的，应该他监听的事件为0
         */
        sk=this.channel.register(selector,0);
        sk.attach(this);
        /**
         * 这里的作用是，SelectionKey的监听事件为OP_READ。interestOps对哪个事件感兴趣
         */
        sk.interestOps(SelectionKey.OP_READ);
        selector.wakeup();

    }
    @Override
    public void run() {
        executor.execute(new Processer());
    }

    class Processer implements Runnable
    {

        @Override
        public void run() {

        }
    }
}

这个就在Acceptor里面多实例化几个Selector,它处理Read和Write事件。

大致架构弄懂了。后面边看netty源码，边学习nio