源码研读-mina多线程模型

         mina是目前很流行的一个网络应用框架，用以帮助用户构建高性能和高伸缩性的网络应用。称其为网络应用框架，主要是其极强的扩展性，支持包括http，ssh，ftp等在内的多种应用层协议。而它本身封装了底层的TCP, UDP等通信协议，使用也非常方便。本文的重点是分析源码，了解它的多线程模型。源码版本为apache-mina-2.0.7。
为了有助于理解，先简单介绍一下mina的整体架构。如下图所示，其分为三层。在通信层之上，是IOService，提供IO服务，管理连接信息，它包含两个实现，一个是IOAcceptor，位于服务器，一个是IOConnector，处在客户端。在IOService之上，是IOFilterChain，作为一个容器，包含一系列IOFilter，做一些通用的数据处理，像协议的转换，多线程，日志等。最上层是IOHandler，负责执行用户的业务逻辑。




（来源http://mina.apache.org/mina-project/userguide/ch2-basics/application-architecture.html）

       下面将按照服务器启动，连接监听，IO处理的顺序来对mina的多线程框架展开分析。

    protected final Set<SocketAddress> bindInternal(List<? extends SocketAddress> localAddresses) throws Exception {        ....        // cr eates the Acceptor instance and has the local        // executor kick it off.        startupAcceptor();        .....    }    private void startupAcceptor() throws InterruptedException {        ......        // start the acceptor if not already started        Acceptor acceptor = acceptorRef.get();        if (acceptor == null) {            lock.acquire();            acceptor = new Acceptor();            if (acceptorRef.compareAndSet(null, acceptor)) {                executeWorker(acceptor);            } else {                lock.release();            }        }    }    protected final void executeWorker(Runnable worker, String suffix) {        String actualThreadName = threadName;        if (suffix != null) {            actualThreadName = actualThreadName + '-' + suffix;        }        executor.execute(new NamePreservingRunnable(worker, actualThreadName));    }

        服务启动时，创建了一个Acceptor实例并在后台运行。Acceptor 主要用来监听用户的连接请求，看看代码：

    private class Acceptor implements Runnable {        public void run() {            ......            while (selectable) {                try {                    // Detect if we have some keys ready to be processed                    // The select() will be woke up if some new connection                    // have occurred, or if the selector has been explicitly                    // woke up                    int selected = select();                    // this actually sets the selector to OP_ACCEPT,                    // and binds to the port on which this class will                    // listen on                    nHandles += registerHandles();                    // Now, if the number of registred handles is 0, we can                    // quit the loop: we don't have any socket listening                    // for incoming connection.                    if (nHandles == 0) {                        ......                    }                    if (selected > 0) {                        // We have some connection request, let's process                        // them here.                        processHandles(selectedHandles());                    }                    // check to see if any cancellation request has been made.                    nHandles -= unregisterHandles();                } catch (ClosedSelectorException cse) {                    ......                }            }            ......        }        /**         * This method will process new sessions for the Worker class.  All         * keys that have had their status updates as per the Selector.selectedKeys()         * method will be processed here.  Only keys that are ready to accept         * connections are handled here.         * <p/>         * Session objects are created by making new instances of SocketSessionImpl         * and passing the session object to the SocketIoProcessor class.         */        @SuppressWarnings("unchecked")        private void processHandles(Iterator<H> 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) {                    continue;                }                initSession(session, null, null);                // add the session to the SocketIoProcessor                session.getProcessor().add(session);            }        }    }

        Acceptor在监听到有连接时，创建了一个Session，并把该Session添加到IOProcessor的队列中。IOProcessor用来处理读写请求。为了进一步提高系统的性能，这里的IOProcessor默认实现为SimpleIOProcessorPool，池的大小默认为系统内核数+1。SimpleIOProcessorPool选择一个IOProcessor来进一步处理读写请求，代码如下：   

    public final void add(S session) {        getProcessor(session).add(session);    }    /**     * Find the processor associated to a session. If it hasen't be stored into     * the session's attributes, pick a new processor and stores it.     */    @SuppressWarnings("unchecked")    private IoProcessor<S> getProcessor(S session) {        IoProcessor<S> processor = (IoProcessor<S>) 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只是以简单轮转的方式来选择一个IOProcessor来处理Session。对于复杂的应用，也可以针对自己应用的特点定制IOProcessor。另外，值得注意的是，该Session与一个IOProcessor绑在了一起，这样实际的读写请求就只会在同一个线程内，避免了线程之间的同步。继续看IOProcessor的处理：  

 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();    }    /**     * Starts the inner Processor, asking the executor to pick a thread in its     * pool. The Runnable will be renamed     */    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();    }

        Session先被加入到队列中，然后IOProcessor启动了一个新的线程(Processor)来处理队列中Session的IO请求。在收到读的请求之后，Processor会触发IOFilterChain来处理读到的数据。IOFilterChain按拦截器模式设计，支持扩展。而mina框架本身提供了一个ExecutorFilter来支持在应用层实现多线程处理。这样就避免了应用层的阻塞妨碍到IO的读写。

    public final void messageReceived(NextFilter nextFilter, IoSession session, Object message) {        if (eventTypes.contains(IoEventType.MESSAGE_RECEIVED)) {            IoFilterEvent event = new IoFilterEvent(nextFilter, IoEventType.MESSAGE_RECEIVED, session, message);            fireEvent(event);        } else {            nextFilter.messageReceived(session, message);        }    }    protected void fireEvent(IoFilterEvent event) {        executor.execute(event);    }

        注意在这里会首先检查当前的事件是否已被用户指定，只有已指定的事件才会并发处理。所以并法控制需要用户谨慎地选择。当然用户也可以实现自己的并发策略，类似之前的IO处理线程，将同一个session的数据绑定到一个线程。
        由此看来，mina对多线程的控制是非常精细的，尤其是IO处理线程与连接监听线程的分离，设计相当巧妙，值得学习。