Mina代码跟踪（1）

1  NioSocketAcceptor类关系图

　　

1.1 NioSocketAcceptor acceptor = new NioSocketAcceptor(5);

NioSocketAcceptor 初始化顺序

　　AbstractIoService构造函数

    protected AbstractIoService(IoSessionConfig sessionConfig, Executor executor) {
        if (sessionConfig == null) {
            throw new IllegalArgumentException("sessionConfig");
        }

        if (getTransportMetadata() == null) {
            throw new IllegalArgumentException("TransportMetadata");
        }

        if (!getTransportMetadata().getSessionConfigType().isAssignableFrom(
                sessionConfig.getClass())) {
            throw new IllegalArgumentException("sessionConfig type: "
                    + sessionConfig.getClass() + " (expected: "
                    + getTransportMetadata().getSessionConfigType() + ")");
        }

        // Create the listeners, and add a first listener : a activation listener
        // for this service, which will give information on the service state.
        listeners = new IoServiceListenerSupport(this);
        listeners.add(serviceActivationListener);

        // Stores the given session configuration
        this.sessionConfig = sessionConfig;

        // Make JVM load the exception monitor before some transports
        // change the thread context class loader.
        ExceptionMonitor.getInstance();

        if (executor == null) {
            this.executor = Executors.newCachedThreadPool();
            createdExecutor = true;
        } else {
            this.executor = executor;
            createdExecutor = false;
        }

        threadName = getClass().getSimpleName() + '-' + id.incrementAndGet();
    }

    protected AbstractIoAcceptor(IoSessionConfig sessionConfig, Executor executor) {
        super(sessionConfig, executor);
        defaultLocalAddresses.add(null);
    }

AbstractPollingIoAcceptor 构造函数

    private AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,
            Executor executor, IoProcessor<S> processor,
            boolean createdProcessor) {
        super(sessionConfig, executor);

        if (processor == null) {
            throw new IllegalArgumentException("processor");
        }

        this.processor = processor;
        this.createdProcessor = createdProcessor;

        try {
            // Initialize the selector
            init();

            // The selector is now ready, we can switch the
            // flag to true so that incoming connection can be accepted
            selectable = true;
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeIoException("Failed to initialize.", e);
        } finally {
            if (!selectable) {
                try {
                    destroy();
                } catch (Exception e) {
                    ExceptionMonitor.getInstance().exceptionCaught(e);
                }
            }
        }
    }

NioSocketAcceptor 构造函数

    public NioSocketAcceptor(int processorCount) {
        super(new DefaultSocketSessionConfig(), NioProcessor.class, processorCount);
        ((DefaultSocketSessionConfig) getSessionConfig()).init(this);
    }

1.2 IoFilterChain 过滤链

aaarticlea/png;base64,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" alt="" />

acceptor.getFilterChain().addLast("logger", new LoggingFilter());

    /**  AbstractIoService
     * {@inheritDoc}
     */
    public final DefaultIoFilterChainBuilder getFilterChain() {
        if (filterChainBuilder instanceof DefaultIoFilterChainBuilder) {
            return (DefaultIoFilterChainBuilder) filterChainBuilder;
        }

        throw new IllegalStateException(
                    "Current filter chain builder is not a DefaultIoFilterChainBuilder.");
    }

源代码：

public class DefaultIoFilterChainBuilder implements IoFilterChainBuilder {

    private final static Logger LOGGER =
        LoggerFactory.getLogger(DefaultIoFilterChainBuilder.class);
    private final List<Entry> entries;

    /**
     * Creates a new instance with an empty filter list.
     */
    public DefaultIoFilterChainBuilder() {
        entries = new CopyOnWriteArrayList<Entry>();
    }

    /**
     * Creates a new copy of the specified {@link DefaultIoFilterChainBuilder}.
     */
    public DefaultIoFilterChainBuilder(DefaultIoFilterChainBuilder filterChain) {
        if (filterChain == null) {
            throw new IllegalArgumentException("filterChain");
        }
        entries = new CopyOnWriteArrayList<Entry>(filterChain.entries);
    }

addLast

    /**
     * @see IoFilterChain#addLast(String, IoFilter)
     */
    public synchronized void addLast(String name, IoFilter filter) {
        register(entries.size(), new EntryImpl(name, filter));
    }
　　 private void register(int index, Entry e) {
        if (contains(e.getName())) {
            throw new IllegalArgumentException(
                    "Other filter is using the same name: " + e.getName());
        }

        entries.add(index, e);
    }

1.3 IoFilter

aaarticlea/png;base64,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" alt="" />

1.4 IoSessionConfig

1.4 IoProcess

　　aaarticlea/png;base64,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" alt="" />

1.5 acceptor.bind(new InetSocketAddress(this.serverAddr, this.serverPort));

　　最终会运行AbstractPollingIoAcceptor.bindInternal

AbstractPollingIoAcceptor  
  protected final Set<SocketAddress> bindInternal(
            List<? extends SocketAddress> localAddresses) throws Exception {
        // Create a bind request as a Future operation. When the selector
        // have handled the registration, it will signal this future.
        AcceptorOperationFuture request = new AcceptorOperationFuture(
                localAddresses);

        // adds the Registration request to the queue for the Workers
        // to handle
        registerQueue.add(request);

        // creates the Acceptor instance and has the local
        // executor kick it off.
        startupAcceptor();

        // As we just started the acceptor, we have to unblock the select()
        // in order to process the bind request we just have added to the
        // registerQueue.
        wakeup();

        // Now, we wait until this request is completed.
        request.awaitUninterruptibly();

        if (request.getException() != null) {
            throw request.getException();
        }

        // Update the local addresses.
        // setLocalAddresses() shouldn't be called from the worker thread
        // because of deadlock.
        Set<SocketAddress> newLocalAddresses = new HashSet<SocketAddress>();

        for (H handle:boundHandles.values()) {
            newLocalAddresses.add(localAddress(handle));
        }

        return newLocalAddresses;
    }

1.5.1 startupAcceptor（） 使用线程池执行Acceptor

    /**
     * This method is called by the doBind() and doUnbind()
     * methods.  If the acceptor is null, the acceptor object will
     * be created and kicked off by the executor.  If the acceptor
     * object is null, probably already created and this class
     * is now working, then nothing will happen and the method
     * will just return.
     */
    private void startupAcceptor() {
        // If the acceptor is not ready, clear the queues
        // TODO : they should already be clean : do we have to do that ?
        if (!selectable) {
            registerQueue.clear();
            cancelQueue.clear();
        }

        // start the acceptor if not already started
        Acceptor acceptor = acceptorRef.get();

        if (acceptor == null) {
            acceptor = new Acceptor();

            if (acceptorRef.compareAndSet(null, acceptor)) {
                executeWorker(acceptor);
            }
        }
    }

Acceptor（） 实现了Runnable接口 不停的执行

  /**
     * This class is called by the startupAcceptor() method and is
     * placed into a NamePreservingRunnable class.
     * It's a thread accepting incoming connections from clients.
     * The loop is stopped when all the bound handlers are unbound.
     */
    private class Acceptor implements Runnable {
        public void run() {
            assert (acceptorRef.get() == this);

            int nHandles = 0;

            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) {
                        acceptorRef.set(null);

                        if (registerQueue.isEmpty() && cancelQueue.isEmpty()) {
                            assert (acceptorRef.get() != this);
                            break;
                        }

                        if (!acceptorRef.compareAndSet(null, this)) {
                            assert (acceptorRef.get() != this);
                            break;
                        }

                        assert (acceptorRef.get() == this);
                    }

                    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) {
                    // If the selector has been closed, we can exit the loop
                    break;
                } catch (Throwable e) {
                    ExceptionMonitor.getInstance().exceptionCaught(e);

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e1) {
                        ExceptionMonitor.getInstance().exceptionCaught(e1);
                    }
                }
            }

            // Cleanup all the processors, and shutdown the acceptor.
            if (selectable && isDisposing()) {
                selectable = false;
                try {
                    if (createdProcessor) {
                        processor.dispose();
                    }
                } finally {
                    try {
                        synchronized (disposalLock) {
                            if (isDisposing()) {
                                destroy();
                            }
                        }
                    } catch (Exception e) {
                        ExceptionMonitor.getInstance().exceptionCaught(e);
                    } finally {
                        disposalFuture.setDone();
                    }
                }
            }
        }

NioSocketAcceptor
    /**
      * Check if we have at least one key whose corresponding channels is
      * ready for I/O operations.
      *
      * This method performs a blocking selection operation.
      * It returns only after at least one channel is selected,
      * this selector's wakeup method is invoked, or the current thread
      * is interrupted, whichever comes first.
      *
      * @return The number of keys having their ready-operation set updated
      * @throws IOException If an I/O error occurs
      * @throws ClosedSelectorException If this selector is closed
      */
    @Override
    protected int select() throws Exception {
        return selector.select();
    }

请问

  /**
     * Sets up the socket communications.  Sets items such as:
     * <p/>
     * Blocking
     * Reuse address
     * Receive buffer size
     * Bind to listen port
     * Registers OP_ACCEPT for selector
     */
    private int registerHandles() {
        for (;;) {
            // The register queue contains the list of services to manage
            // in this acceptor.
            AcceptorOperationFuture future = registerQueue.poll();

            if (future == null) {
                return 0;
            }

            // We create a temporary map to store the bound handles,
            // as we may have to remove them all if there is an exception
            // during the sockets opening.
            Map<SocketAddress, H> newHandles = new ConcurrentHashMap<SocketAddress, H>();
            List<SocketAddress> localAddresses = future.getLocalAddresses();

            try {
                // Process all the addresses
                for (SocketAddress a : localAddresses) {
                    H handle = open(a);
                    newHandles.put(localAddress(handle), handle);
                }

                // Everything went ok, we can now update the map storing
                // all the bound sockets.
                boundHandles.putAll(newHandles);

                // and notify.
                future.setDone();
                return newHandles.size();
            } catch (Exception e) {
                // We store the exception in the future
                future.setException(e);
            } finally {
                // Roll back if failed to bind all addresses.
                if (future.getException() != null) {
                    for (H handle : newHandles.values()) {
                        try {
                            close(handle);
                        } catch (Exception e) {
                            ExceptionMonitor.getInstance().exceptionCaught(e);
                        }
                    }

                    // TODO : add some comment : what is the wakeup() waking up ?
                    wakeup();
                }
            }
        }
    }

接上图open方法 jdk自带的NIO

    /**
     * {@inheritDoc}
     */
    @Override
    protected ServerSocketChannel open(SocketAddress localAddress)
            throws Exception {
        // Creates the listening ServerSocket
        ServerSocketChannel channel = ServerSocketChannel.open();

        boolean success = false;

        try {
            // This is a non blocking socket channel
            channel.configureBlocking(false);

            // Configure the server socket,
            ServerSocket socket = channel.socket();

            // Set the reuseAddress flag accordingly with the setting
            socket.setReuseAddress(isReuseAddress());

            // and bind.
            socket.bind(localAddress, getBacklog());

            // Register the channel within the selector for ACCEPT event
            channel.register(selector, SelectionKey.OP_ACCEPT);
            success = true;
        } finally {
            if (!success) {
                close(channel);
            }
        }
        return channel;
    }

Acceptor接收数据

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

        /**
         * 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) {
                    break;
                }
　　　　　　　　　　//初始化session
                initSession(session, null, null);

                // add the session to the SocketIoProcessor 过滤链处理数据入口
                session.getProcessor().add(session);
            }
        }

processHandles 的accept 获取SocketChannel 封装成NioSocketSession

    protected NioSession accept(IoProcessor<NioSession> processor,
            ServerSocketChannel handle) throws Exception {

        SelectionKey key = handle.keyFor(selector);

        if ((key == null) || (!key.isValid()) || (!key.isAcceptable()) ) {
            return null;
        }

        // accept the connection from the client
        SocketChannel ch = handle.accept();

        if (ch == null) {
            return null;
        }

        return new NioSocketSession(this, processor, ch);
    }

processor

    /**
     * {@inheritDoc}
     */
    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();
    }

主要接收数据处理代码逻辑

  /**
     * The main loop. This is the place in charge to poll the Selector, and to
     * process the active sessions. It's done in
     * - handle the newly created sessions
     * -
     */
    private class Processor implements Runnable {
        public void run() {
            assert (processorRef.get() == this);

            int nSessions = 0;
            lastIdleCheckTime = System.currentTimeMillis();

            for (;;) {
                try {
                    // This select has a timeout so that we can manage
                    // idle session when we get out of the select every
                    // second. (note : this is a hack to avoid creating
                    // a dedicated thread).
                    long t0 = System.currentTimeMillis();
                    int selected = select(SELECT_TIMEOUT);
                    long t1 = System.currentTimeMillis();
                    long delta = (t1 - t0);

                    if ((selected == 0) && !wakeupCalled.get() && (delta < 100)) {
                        // Last chance : the select() may have been
                        // interrupted because we have had an closed channel.
                        if (isBrokenConnection()) {
                            LOG.warn("Broken connection");

                            // we can reselect immediately
                            // set back the flag to false
                            wakeupCalled.getAndSet(false);

                            continue;
                        } else {
                            LOG.warn("Create a new selector. Selected is 0, delta = "
                                            + (t1 - t0));
                            // Ok, we are hit by the nasty epoll
                            // spinning.
                            // Basically, there is a race condition
                            // which causes a closing file descriptor not to be
                            // considered as available as a selected channel, but
                            // it stopped the select. The next time we will
                            // call select(), it will exit immediately for the same
                            // reason, and do so forever, consuming 100%
                            // CPU.
                            // We have to destroy the selector, and
                            // register all the socket on a new one.
                            registerNewSelector();
                        }

                        // Set back the flag to false
                        wakeupCalled.getAndSet(false);

                        // and continue the loop
                        continue;
                    }

                    // Manage newly created session first
                    nSessions += handleNewSessions();

                    updateTrafficMask();

                    // Now, if we have had some incoming or outgoing events,
                    // deal with them
                    if (selected > 0) {
                        //LOG.debug("Processing ..."); // This log hurts one of the MDCFilter test...
                        process();
                    }

                    // Write the pending requests
                    long currentTime = System.currentTimeMillis();
                    flush(currentTime);

                    // And manage removed sessions
                    nSessions -= removeSessions();

                    // Last, not least, send Idle events to the idle sessions
                    notifyIdleSessions(currentTime);

                    // Get a chance to exit the infinite loop if there are no
                    // more sessions on this Processor
                    if (nSessions == 0) {
                        processorRef.set(null);

                        if (newSessions.isEmpty() && isSelectorEmpty()) {
                            // newSessions.add() precedes startupProcessor
                            assert (processorRef.get() != this);
                            break;
                        }

                        assert (processorRef.get() != this);

                        if (!processorRef.compareAndSet(null, this)) {
                            // startupProcessor won race, so must exit processor
                            assert (processorRef.get() != this);
                            break;
                        }

                        assert (processorRef.get() == this);
                    }

                    // Disconnect all sessions immediately if disposal has been
                    // requested so that we exit this loop eventually.
                    if (isDisposing()) {
                        for (Iterator<S> i = allSessions(); i.hasNext();) {
                            scheduleRemove(i.next());
                        }

                        wakeup();
                    }
                } catch (ClosedSelectorException cse) {
                    // If the selector has been closed, we can exit the loop
                    break;
                } catch (Throwable t) {
                    ExceptionMonitor.getInstance().exceptionCaught(t);

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e1) {
                        ExceptionMonitor.getInstance().exceptionCaught(e1);
                    }
                }
            }

            try {
                synchronized (disposalLock) {
                    if (disposing) {
                        doDispose();
                    }
                }
            } catch (Throwable t) {
                ExceptionMonitor.getInstance().exceptionCaught(t);
            } finally {
                disposalFuture.setValue(true);
            }
        }
    }

过滤链：

    private void process() throws Exception {
        for (Iterator<S> i = selectedSessions(); i.hasNext();) {
            S session = i.next();
            process(session);
            i.remove();
        }
    }

    /**
     * Deal with session ready for the read or write operations, or both.
     */
    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);
            }
        }
    }

  private void read(S session) {
        IoSessionConfig config = session.getConfig();
        int bufferSize = config.getReadBufferSize();
        IoBuffer buf = IoBuffer.allocate(bufferSize);

        final boolean hasFragmentation = session.getTransportMetadata()
                .hasFragmentation();

        try {
            int readBytes = 0;
            int ret;

            try {
                if (hasFragmentation) {

                    while ((ret = read(session, buf)) > 0) {
                        readBytes += ret;

                        if (!buf.hasRemaining()) {
                            break;
                        }
                    }
                } else {
                    ret = read(session, buf);

                    if (ret > 0) {
                        readBytes = ret;
                    }
                }
            } finally {
                buf.flip();
            }

            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();
                    }
                }
            }

            if (ret < 0) {
                scheduleRemove(session);
            }
        } catch (Throwable e) {
            if (e instanceof IOException) {
                if (!(e instanceof PortUnreachableException)
                        || !AbstractDatagramSessionConfig.class.isAssignableFrom(config.getClass())
                        || ((AbstractDatagramSessionConfig) config).isCloseOnPortUnreachable()) {
                    scheduleRemove(session);
                }
            }

            IoFilterChain filterChain = session.getFilterChain();
            filterChain.fireExceptionCaught(e);
        }
    }

调用过滤连： 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);
        }
    }

业务处理handler总是最后处理