Mina主体逻辑流程

Mina也是一个one loop per thread的Reactor框架，关于这部分的知识可以看看《muduo网络库》这本书，Mina的优化什么的我看的不是很仔细，而且很多看不懂。这一篇博客主要从上层代码走一下Mina的主要逻辑流程。

简单介绍

Mina有几个主要的组件，分别是IoService，IoBuffer，IoFilter，IoHandler，IoSession，IoFuture（这部分简要介绍了参考资料中关于Mina的资料，可详细阅读参考资料）

Mina的命名规范都是一个IoXXX接口，然后AbstractIoXXX定义主要逻辑过程的抽象类，然后就是具体的实现一般是NIOXXX

• IoBuffer是一个抽象类，基本是对Java NIO的Buffer的封装使用，基本上只有setAllocator的一些实现AbstractIoBuffer 是IoBuffer的具体实现类，包含了expand和shrink以及put和get的方法

  • IoBufferAllocator是一个接口，具体实现有两个，内部类中包含了AbstractIoBuffer 的具体实现：

  SimpleBufferAllocator最基本的使用

  CachedBuffer如果频繁的扩充，那么就会多机器有压力，所以提前以2的幂去存储一堆已经生成的Buffer Map，存到ThreadLocal中，然后直接调用

• IoService 用来管理各种IO服务，在mina中，这些服务可以包括session、filter、handler等

  AbstractIoService 负责初始化组建，关闭，初始化session（使用IoService中的属性最后去初始化AttributeMap），以及初始化一些IoService中包含的一些属性。

整体代码流程

public class MinaAcceptorThread implements Runnable {
    @Override
    public void run() {
        MinaClientHandler handler = new MinaClientHandler();
        NioSocketAcceptor acceptor = new NioSocketAcceptor();
        acceptor.setReuseAddress(true);
        acceptor.getFilterChain().addLast("protocol", new ProtocolCodecFilter(new IMCodeFactory(false)));
        acceptor.setDefaultLocalAddress(new InetSocketAddress(PathConstant.PORT));
        acceptor.setHandler(handler);
        try {
            acceptor.bind();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

NioSocketAcceptor会在初始化时调用

protected AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,
        Class> processorClass) {
    this(sessionConfig, null, new SimpleIoProcessorPool(processorClass),
            true);
}

NioSocketAcceptor中的selector只负责接收新的连接，具体的one loop per thread是由SimpleIoProcessorPool实现的。

SimpleIoProcessorPool中默认的线程池this.executor = Executors.newCachedThreadPool();SimpleIoProcessorPool中的pool是提前生成的CPU个数+1的NIOProcessor

NioSocketAcceptor接收到新的连接时执行

if (selected > 0) {
    // We have some connection request, let's process 
    // them here. 
    processHandles(selectedHandles());
}

初始化session的过程没有细看

private void processHandles(Iterator handles) throws Exception {
    while (handles.hasNext()) {
        H handle = handles.next();
        handles.remove();

        // Associates a new created connection to a processor,
        // and get back a session
        S session = accept(processor, handle);

        if (session == null) {
            break;
        }

        initSession(session, null, null);

        // add the session to the SocketIoProcessor
        session.getProcessor().add(session);
    }
}

加入SimpleIoProcessorPool的时候会将session与processor绑定，也就是连接绑定processor。

private IoProcessor getProcessor(S session) {
        IoProcessor processor = (IoProcessor) session.getAttribute(PROCESSOR);

        if (processor == null) {
            if (disposed || disposing) {
                throw new IllegalStateException("A disposed processor cannot be accessed.");
            }

            processor = pool[Math.abs((int) session.getId()) % pool.length];

            if (processor == null) {
                throw new IllegalStateException("A disposed processor cannot be accessed.");
            }

            session.setAttributeIfAbsent(PROCESSOR, processor);
        }

        return processor;
    }

SimpleIoProcessorPool中的pool是提前生成的CPU个数+1的NIOProcessor

public final void add(S session) {
        if (disposed || disposing) {
            throw new IllegalStateException("Already disposed.");
        }

        // Adds the session to the newSession queue and starts the worker
        newSessions.add(session);
        startupProcessor();
    }

接下来就是执行AbstractPollingIoProcessor中内部的Processor类，也就是在线程池中

private void startupProcessor() {
        Processor processor = processorRef.get();

        if (processor == null) {
            processor = new Processor();

            if (processorRef.compareAndSet(null, processor)) {
                executor.execute(new NamePreservingRunnable(processor, threadName));
            }
        }

        // Just stop the select() and start it again, so that the processor
        // can be activated immediately.
        wakeup();
    }

这部分也就是每个NIO具体在select分配过来的网络连接

nSessions += handleNewSessions();//创建FilterChain过程
....
//处理过程  
if (selected > 0) {
    process();
}

具体处理数据的过程

private void process(S session) {
        // Process Reads
        if (isReadable(session) && !session.isReadSuspended()) {
            read(session);
        }

        // Process writes
        if (isWritable(session) && !session.isWriteSuspended()) {
            // add the session to the queue, if it's not already there
            if (session.setScheduledForFlush(true)) {
                flushingSessions.add(session);
            }
        }
    }

以read为例

private void read(S session) {
        ...
            if (readBytes > 0) {
                IoFilterChain filterChain = session.getFilterChain();
                filterChain.fireMessageReceived(buf);
                buf = null;

                if (hasFragmentation) {
                    if (readBytes << 1 < config.getReadBufferSize()) {
                        session.decreaseReadBufferSize();
                    } else if (readBytes == config.getReadBufferSize()) {
                        session.increaseReadBufferSize();
                    }
                }
            }
...

调用IoFilterChain就开始了对数据解析以及最终用户通过IoHandler得到具体的网络通信数据。FilterChain的流程在DefaultIoFilterChain中定义

public void fireMessageReceived(Object message) {
        if (message instanceof IoBuffer) {
            session.increaseReadBytes(((IoBuffer) message).remaining(), System
                    .currentTimeMillis());
        }

        Entry head = this.head;
        callNextMessageReceived(head, session, message);
    }

    private void callNextMessageReceived(Entry entry, IoSession session,
            Object message) {
        try {
            IoFilter filter = entry.getFilter();
            NextFilter nextFilter = entry.getNextFilter();
            filter.messageReceived(nextFilter, session,
                    message);
        } catch (Throwable e) {
            fireExceptionCaught(e);
        }
    }

CumulativeProtocolDecoder可以帮助你积累未收完的一条消息，doDecode返回false会使用IoBuffer缓存该消息。

public void messageReceived(NextFilter nextFilter, IoSession session,
            Object message) throws Exception {
        LOGGER.debug( "Processing a MESSAGE_RECEIVED for session {}", session.getId() );

        if (!(message instanceof IoBuffer)) {
            nextFilter.messageReceived(session, message);
            return;
        }

        IoBuffer in = (IoBuffer) message;
        ProtocolDecoder decoder = factory.getDecoder(session);
        ProtocolDecoderOutput decoderOut = getDecoderOut(session, nextFilter);

        // Loop until we don't have anymore byte in the buffer,
        // or until the decoder throws an unrecoverable exception or 
        // can't decoder a message, because there are not enough 
        // data in the buffer
        while (in.hasRemaining()) {
            int oldPos = in.position();

            try {
                synchronized (decoderOut) {
                    // Call the decoder with the read bytes
                    decoder.decode(session, in, decoderOut);
                }

                // Finish decoding if no exception was thrown.
                decoderOut.flush(nextFilter, session);
            } catch (Throwable t) {
              ...

最后看看在DefaultIoFilterChain中如何实现IoFilterChain与IoHandler结合成一个链条。DefaultIoFilterChain中的Entry最后由DefaultIoFilterChainImpl中buildFilterChain把Entry插入IoFilterChain。Entry中包含了IoFilter，Entry是IoFilterChain的包装

接上面创建FilterChain过程

nSessions += handleNewSessions();

handlerNewSessions()->addNow()会将初始化时addLast的IoFilterChain（也就是一开始代码中的acceptor.getFilterChain().addLast(“protocol”, new ProtocolCodecFilter(new IMCodeFactory(false)));）

通过bulider生成DefaultIoFilterChain中Entry的链子

public void buildFilterChain(IoFilterChain chain) throws Exception {
        for (Entry e : entries) {
            chain.addLast(e.getName(), e.getFilter());
        }
    }

DefaultIoFilterChain在初始化时会

public DefaultIoFilterChain(AbstractIoSession session) {
        if (session == null) {
            throw new IllegalArgumentException("session");
        }

        this.session = session;
        head = new EntryImpl(null, null, "head", new HeadFilter());
        tail = new EntryImpl(head, null, "tail", new TailFilter());
        head.nextEntry = tail;
    }

Head主要是flush发送缓冲区（具体关于send的过程没有详细阅读）

if (!s.isWriteSuspended()) {
    s.getProcessor().flush(s);
}

Tail是IoHandler，看一眼就明白了

private static class TailFilter extends IoFilterAdapter {
        @Override
        public void sessionCreated(NextFilter nextFilter, IoSession session)
                throws Exception {
            try {
                session.getHandler().sessionCreated(session);
            } finally {
                // Notify the related future.
                ConnectFuture future = (ConnectFuture) session
                        .removeAttribute(SESSION_CREATED_FUTURE);
                if (future != null) {
                    future.setSession(session);
                }
            }
        }

疑惑：

1. 为什么要synchronized (decoderOut)每一个session都被指定的processpr执行，不应该出现多线程的问题啊？
2. IoService 中的线程池是做什么的
3. Mina中的多线程问题

下一篇博客内容

• 知道了主要的Mina流程，下一篇我将比较详细介绍一下各个组件以及之间的关系
• Mina在实现应用层协议时应该注意哪些问题

参考资料

系列介绍

Mina官方文档

资料

资料

Mina实现自定义应用层协议

Java NIO基础

多selector介绍