/**

 * 处理指定的连接

 * @param socket The socket channel

 * @return

 *  如果socket配置正确，并且可能会继续处理，返回true

 *  如果socket需要立即关闭，则返回false

 */

protected boolean setSocketOptions(SocketChannel socket) {

    // Process the connection

    try {

        //非阻塞模式

        socket.configureBlocking(false);

        Socket sock = socket.socket();

        socketProperties.setProperties(sock);

		//从缓存中拿一个nioChannel  若没有，则创建一个。将socket传进去

        NioChannel channel = nioChannels.pop();

        if (channel == null) {

            SocketBufferHandler bufhandler = new SocketBufferHandler(

                    socketProperties.getAppReadBufSize(),

                    socketProperties.getAppWriteBufSize(),

                    socketProperties.getDirectBuffer());

            if (isSSLEnabled()) {

                channel = new SecureNioChannel(socket, bufhandler, selectorPool, this);

            } else {

                channel = new NioChannel(socket, bufhandler);

            }

        } else {

            channel.setIOChannel(socket);

            channel.reset();

        }

		//从pollers数组中获取一个Poller对象，注册这个nioChannel

        getPoller0().register(channel);

    } catch (Throwable t) {

        ExceptionUtils.handleThrowable(t);

        try {

            log.error("",t);

        } catch (Throwable tt) {

            ExceptionUtils.handleThrowable(tt);

        }

        // Tell to close the socket

        return false;

    }

    return true;

}

/**

 * 使用轮询器注册新创建的socket

 *

 * @param socket    新创建的socket

 */

public void register(final NioChannel socket) {

    socket.setPoller(this);

	//创建一个NioSocketWrapper，包装一下socket。然后一顿设置。

    NioSocketWrapper ka = new NioSocketWrapper(socket, NioEndpoint.this);

    socket.setSocketWrapper(ka);

    ka.setPoller(this);

    ka.setReadTimeout(getSocketProperties().getSoTimeout());

    ka.setWriteTimeout(getSocketProperties().getSoTimeout());

    ka.setKeepAliveLeft(NioEndpoint.this.getMaxKeepAliveRequests());

    ka.setSecure(isSSLEnabled());

    ka.setReadTimeout(getConnectionTimeout());

    ka.setWriteTimeout(getConnectionTimeout());

	//从缓存中取出一个PollerEvent对象，若没有则创建一个。将socket和NioSocketWrapper设置进去

    PollerEvent r = eventCache.pop();

    ka.interestOps(SelectionKey.OP_READ);//this is what OP_REGISTER turns into.

    if ( r==null) r = new PollerEvent(socket,ka,OP_REGISTER);

    else r.reset(socket,ka,OP_REGISTER);

	//添到到该Poller的事件列表

    addEvent(r);

}

/**

 * The background thread that adds sockets to the Poller, checks the

 * poller for triggered events and hands the associated socket off to an

 * appropriate processor as events occur.

 */

@Override

public void run() {

    // 循环直到 destroy() 被调用

    while (true) {

        boolean hasEvents = false;

        try {

            if (!close) {

				//将events队列，将每个事件中的通道感兴趣的事件注册到Selector中

                hasEvents = events();

                if (wakeupCounter.getAndSet(-1) > 0) {

                    //如果走到了这里，代表已经有就绪的IO通道

                    //调用非阻塞的select方法，直接返回就绪通道的数量

                    keyCount = selector.selectNow();

                } else {

					//阻塞等待操作系统返回 数据已经就绪的通道，然后被唤醒

                    keyCount = selector.select(selectorTimeout);

                }

                wakeupCounter.set(0);

            }

            if (close) {

                events();

                timeout(0, false);

                try {

                    selector.close();

                } catch (IOException ioe) {

                    log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);

                }

                break;

            }

        } catch (Throwable x) {

            ExceptionUtils.handleThrowable(x);

            log.error("",x);

            continue;

        }

        //如果上面select方法超时，或者被唤醒，先将events队列中的通道注册到Selector上。

        if ( keyCount == 0 ) hasEvents = (hasEvents | events());

        Iterator<SelectionKey> iterator =

            keyCount > 0 ? selector.selectedKeys().iterator() : null;

        // 遍历已就绪的通道，并调用processKey来处理该Socket的IO。

        while (iterator != null && iterator.hasNext()) {

            SelectionKey sk = iterator.next();

            NioSocketWrapper attachment = (NioSocketWrapper)sk.attachment();

            // 如果其它线程已调用，则Attachment可能为空

            if (attachment == null) {

                iterator.remove();

            } else {

                iterator.remove();

				//创建一个SocketProcessor，放入Tomcat线程池去执行

                processKey(sk, attachment);

            }

        }//while

        //process timeouts

        timeout(keyCount,hasEvents);

    }//while

    getStopLatch().countDown();

}

/**

 * Processes events in the event queue of the Poller.

 *

 * @return <code>true</code> if some events were processed,

 *   <code>false</code> if queue was empty

 */

public boolean events() {

    boolean result = false;

    PollerEvent pe = null;

    while ( (pe = events.poll()) != null ) {

        result = true;

        try {

			//把SocketChannel感兴趣的事件注册到Selector中

            pe.run();

            pe.reset();

            if (running && !paused) {

                eventCache.push(pe);

            }

        } catch ( Throwable x ) {

            log.error("",x);

        }

    }

    return result;

}

public void run() {

	//Acceptor调用Poller.register()方法时，创建的PollerEvent感兴趣的事件为OP_REGISTER，因此走这个分支

    if (interestOps == OP_REGISTER) {

        try {

			//将SocketChannel的读事件注册到Poller线程的Selector中，使用Selector来调度IO。

            socket.getIOChannel().register(

                    socket.getPoller().getSelector(), SelectionKey.OP_READ, socketWrapper);

        } catch (Exception x) {

            log.error(sm.getString("endpoint.nio.registerFail"), x);

        }

    } else {

        final SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());

        try {

            if (key == null) {

                // The key was cancelled (e.g. due to socket closure)

                // and removed from the selector while it was being

                // processed. Count down the connections at this point

                // since it won't have been counted down when the socket

                // closed.

                socket.socketWrapper.getEndpoint().countDownConnection();

            } else {

                final NioSocketWrapper socketWrapper = (NioSocketWrapper) key.attachment();

                if (socketWrapper != null) {

                    //we are registering the key to start with, reset the fairness counter.

                    int ops = key.interestOps() | interestOps;

                    socketWrapper.interestOps(ops);

                    key.interestOps(ops);

                } else {

                    socket.getPoller().cancelledKey(key);

                }

            }

        } catch (CancelledKeyException ckx) {

            try {

                socket.getPoller().cancelledKey(key);

            } catch (Exception ignore) {}

        }

    }

}